| // RUN: mlir-opt %s --pass-pipeline="builtin.module(acc-implicit-declare)" -split-input-file 2>&1 | FileCheck %s |
| |
| // ----- |
| |
| // Test that non-constant scalar globals in compute regions are hoisted |
| // instead of being marked with acc declare |
| |
| memref.global @gscalar : memref<f32> = dense<0.0> |
| |
| func.func @test_scalar_in_serial() { |
| acc.serial { |
| %addr = memref.get_global @gscalar : memref<f32> |
| %load = memref.load %addr[] : memref<f32> |
| acc.yield |
| } |
| return |
| } |
| |
| // Expected to hoist this global access out of acc region instead of marking |
| // with `acc declare`. |
| // CHECK-LABEL: func.func @test_scalar_in_serial |
| // CHECK: memref.get_global @gscalar |
| // CHECK: acc.serial |
| // CHECK-NOT: acc.declare |
| |
| // ----- |
| |
| // Test that constant globals are marked with acc declare |
| |
| memref.global constant @gscalarconst : memref<f32> = dense<1.0> |
| |
| func.func @test_constant_in_serial() { |
| acc.serial { |
| %addr = memref.get_global @gscalarconst : memref<f32> |
| %load = memref.load %addr[] : memref<f32> |
| acc.yield |
| } |
| return |
| } |
| |
| // This is expected to be `acc declare`'d since it is a constant. |
| // CHECK: memref.global constant @gscalarconst {{.*}} {acc.declare = #acc.declare<dataClause = acc_copyin>} |
| |
| // ----- |
| |
| // Test globals referenced in acc routine functions |
| |
| memref.global @gscalar_routine : memref<f32> = dense<0.0> |
| |
| acc.routine @acc_routine_0 func(@test_scalar_in_accroutine) |
| func.func @test_scalar_in_accroutine() attributes {acc.routine_info = #acc.routine_info<[@acc_routine_0]>} { |
| %addr = memref.get_global @gscalar_routine : memref<f32> |
| %load = memref.load %addr[] : memref<f32> |
| return |
| } |
| |
| // Global should be acc declare'd because it's in an acc routine |
| // CHECK: memref.global @gscalar_routine {{.*}} {acc.declare = #acc.declare<dataClause = acc_copyin>} |
| |
| // ----- |
| |
| // Test constant globals in acc routine |
| |
| memref.global constant @gscalarconst_routine : memref<f32> = dense<1.0> |
| |
| acc.routine @acc_routine_0 func(@test_constant_in_accroutine) |
| func.func @test_constant_in_accroutine() attributes {acc.routine_info = #acc.routine_info<[@acc_routine_0]>} { |
| %addr = memref.get_global @gscalarconst_routine : memref<f32> |
| %load = memref.load %addr[] : memref<f32> |
| return |
| } |
| |
| // CHECK: memref.global constant @gscalarconst_routine {{.*}} {acc.declare = #acc.declare<dataClause = acc_copyin>} |
| |
| // ----- |
| |
| // Test acc.private.recipe with global reference - referenced variant |
| |
| memref.global @global_for_private : memref<f32> = dense<0.0> |
| |
| acc.private.recipe @private_recipe_with_global : memref<f32> init { |
| ^bb0(%arg0: memref<f32>): |
| %0 = memref.alloc() : memref<f32> |
| %global_addr = memref.get_global @global_for_private : memref<f32> |
| %global_val = memref.load %global_addr[] : memref<f32> |
| memref.store %global_val, %0[] : memref<f32> |
| acc.yield %0 : memref<f32> |
| } destroy { |
| ^bb0(%arg0: memref<f32>): |
| memref.dealloc %arg0 : memref<f32> |
| acc.terminator |
| } |
| |
| func.func @test_private_recipe_referenced() { |
| %var = memref.alloc() : memref<f32> |
| %priv = acc.private varPtr(%var : memref<f32>) recipe(@private_recipe_with_global) -> memref<f32> |
| acc.parallel private(%priv : memref<f32>) { |
| %load = memref.load %var[] : memref<f32> |
| acc.yield |
| } |
| memref.dealloc %var : memref<f32> |
| return |
| } |
| |
| // Global should be acc declare'd because the recipe is referenced |
| // CHECK: memref.global @global_for_private {{.*}} {acc.declare = #acc.declare<dataClause = acc_copyin>} |
| |
| // ----- |
| |
| // Test acc.private.recipe with global reference - unreferenced variant |
| |
| memref.global @global_for_private_unused : memref<f32> = dense<0.0> |
| |
| acc.private.recipe @private_recipe_unused : memref<f32> init { |
| ^bb0(%arg0: memref<f32>): |
| %0 = memref.alloc() : memref<f32> |
| %global_addr = memref.get_global @global_for_private_unused : memref<f32> |
| %global_val = memref.load %global_addr[] : memref<f32> |
| memref.store %global_val, %0[] : memref<f32> |
| acc.yield %0 : memref<f32> |
| } destroy { |
| ^bb0(%arg0: memref<f32>): |
| memref.dealloc %arg0 : memref<f32> |
| acc.terminator |
| } |
| |
| func.func @test_private_recipe_not_referenced() { |
| %var = memref.alloc() : memref<f32> |
| acc.parallel { |
| %load = memref.load %var[] : memref<f32> |
| acc.yield |
| } |
| memref.dealloc %var : memref<f32> |
| return |
| } |
| |
| // Global should NOT be acc declare'd because the recipe is not referenced |
| // CHECK-NOT: memref.global @global_for_private_unused {{.*}} {acc.declare |
| |
| // ----- |
| |
| // Test globals in different compute constructs (parallel, kernels, serial) |
| |
| memref.global @global_parallel : memref<f32> = dense<0.0> |
| memref.global @global_kernels : memref<f32> = dense<0.0> |
| memref.global constant @global_serial_const : memref<f32> = dense<1.0> |
| |
| func.func @test_multiple_constructs() { |
| acc.parallel { |
| %addr = memref.get_global @global_parallel : memref<f32> |
| %load = memref.load %addr[] : memref<f32> |
| acc.yield |
| } |
| acc.kernels { |
| %addr = memref.get_global @global_kernels : memref<f32> |
| %load = memref.load %addr[] : memref<f32> |
| acc.terminator |
| } |
| acc.serial { |
| %addr = memref.get_global @global_serial_const : memref<f32> |
| %load = memref.load %addr[] : memref<f32> |
| acc.yield |
| } |
| return |
| } |
| |
| // Non-constant globals ARE hoisted before their compute regions |
| // Constant global should be marked with acc.declare |
| // CHECK: memref.global constant @global_serial_const {{.*}} {acc.declare = #acc.declare<dataClause = acc_copyin>} |
| // CHECK-LABEL: func.func @test_multiple_constructs |
| // CHECK: memref.get_global @global_parallel |
| // CHECK-NEXT: acc.parallel |
| // CHECK: memref.get_global @global_kernels |
| // CHECK-NEXT: acc.kernels |
| |
| // ----- |
| |
| memref.global @global_in_compute_region : memref<f32> = dense<0.0> |
| |
| func.func @test_scalar_in_compute_region() { |
| acc.compute_region { |
| %addr = memref.get_global @global_in_compute_region : memref<f32> |
| %load = memref.load %addr[] : memref<f32> |
| acc.yield |
| } {origin = "acc.parallel"} |
| return |
| } |
| |
| // When hoisting out of acc.compute_region, block arguments must be used to |
| // wire the value through. |
| // CHECK-LABEL: func.func @test_scalar_in_compute_region |
| // CHECK: %[[G:.*]] = memref.get_global @global_in_compute_region |
| // CHECK: acc.compute_region ins(%[[INS_ARG:.*]] = %[[G]]) : (memref<f32>) { |
| // CHECK: memref.load %[[INS_ARG]][] : memref<f32> |
| // CHECK-NOT: memref.load %[[G]][] : memref<f32> |
| |
