This is an archive of the discontinued LLVM Phabricator instance.

Differential D148278

[flang][openacc] Add kernels construct lowering
ClosedPublic

Authored by clementval on Apr 13 2023, 4:32 PM.

Details

Reviewers
PeteSteinfeld
razvanlupusoru
Commits
rG3163f7ade255: [flang][openacc] Add kernels construct lowering
Summary

Lower the parse tree to acc dialects operations. Make use
of the compute construct lowering.

Depends on D148277

Diff Detail

Event Timeline

clementval created this revision.Apr 13 2023, 4:32 PM
Herald added projects: Restricted Project, Restricted Project. · View Herald TranscriptApr 13 2023, 4:32 PM
Herald added subscribers: sunshaoce, mehdi_amini. · View Herald Transcript
clementval requested review of this revision.Apr 13 2023, 4:32 PM
Herald added a subscriber: jdoerfert. · View Herald TranscriptApr 13 2023, 4:32 PM
Harbormaster completed remote builds in B225456: Diff 513384.Apr 13 2023, 4:33 PM
PeteSteinfeld accepted this revision.Apr 13 2023, 6:30 PM

All builds and tests correctly and looks good.

This revision is now accepted and ready to land.Apr 13 2023, 6:30 PM
clementval updated this revision to Diff 513612.Apr 14 2023, 8:32 AM

Rebase

Harbormaster completed remote builds in B225631: Diff 513612.Apr 14 2023, 9:18 AM
Closed by commit rG3163f7ade255: [flang][openacc] Add kernels construct lowering (authored by clementval). · Explain WhyApr 14 2023, 9:44 AM
This revision was automatically updated to reflect the committed changes.
clementval added a commit: rG3163f7ade255: [flang][openacc] Add kernels construct lowering.

Revision Contents

PathSize
flang/
lib/
Lower/
28 lines
test/
Lower/
OpenACC/
684 lines
239 lines

Diff 513638

flang/lib/Lower/OpenACC.cpp

Show First 20 Lines • Show All 545 Lines • ▼ Show 20 Lines for (const Fortran::parser::AccClause &clause : accClauseList.v) {
} }
} }
// Prepare the operand segement size attribute and the operands value range. // Prepare the operand segement size attribute and the operands value range.
llvm::SmallVector<mlir::Value, 8> operands; llvm::SmallVector<mlir::Value, 8> operands;
llvm::SmallVector<int32_t, 8> operandSegments; llvm::SmallVector<int32_t, 8> operandSegments;
addOperand(operands, operandSegments, async); addOperand(operands, operandSegments, async);
addOperands(operands, operandSegments, waitOperands); addOperands(operands, operandSegments, waitOperands);
if constexpr (std::is_same_v<Op, mlir::acc::ParallelOp>) { if constexpr (!std::is_same_v<Op, mlir::acc::SerialOp>) {
addOperand(operands, operandSegments, numGangs); addOperand(operands, operandSegments, numGangs);
addOperand(operands, operandSegments, numWorkers); addOperand(operands, operandSegments, numWorkers);
addOperand(operands, operandSegments, vectorLength); addOperand(operands, operandSegments, vectorLength);
} }
addOperand(operands, operandSegments, ifCond); addOperand(operands, operandSegments, ifCond);
addOperand(operands, operandSegments, selfCond); addOperand(operands, operandSegments, selfCond);
if constexpr (!std::is_same_v<Op, mlir::acc::KernelsOp>)
addOperands(operands, operandSegments, reductionOperands); addOperands(operands, operandSegments, reductionOperands);
addOperands(operands, operandSegments, copyOperands); addOperands(operands, operandSegments, copyOperands);
addOperands(operands, operandSegments, copyinOperands); addOperands(operands, operandSegments, copyinOperands);
addOperands(operands, operandSegments, copyinReadonlyOperands); addOperands(operands, operandSegments, copyinReadonlyOperands);
addOperands(operands, operandSegments, copyoutOperands); addOperands(operands, operandSegments, copyoutOperands);
addOperands(operands, operandSegments, copyoutZeroOperands); addOperands(operands, operandSegments, copyoutZeroOperands);
addOperands(operands, operandSegments, createOperands); addOperands(operands, operandSegments, createOperands);
addOperands(operands, operandSegments, createZeroOperands); addOperands(operands, operandSegments, createZeroOperands);
addOperands(operands, operandSegments, noCreateOperands); addOperands(operands, operandSegments, noCreateOperands);
addOperands(operands, operandSegments, presentOperands); addOperands(operands, operandSegments, presentOperands);
addOperands(operands, operandSegments, devicePtrOperands); addOperands(operands, operandSegments, devicePtrOperands);
addOperands(operands, operandSegments, attachOperands); addOperands(operands, operandSegments, attachOperands);
if constexpr (!std::is_same_v<Op, mlir::acc::KernelsOp>) {
addOperands(operands, operandSegments, privateOperands); addOperands(operands, operandSegments, privateOperands);
addOperands(operands, operandSegments, firstprivateOperands); addOperands(operands, operandSegments, firstprivateOperands);
}
Op computeOp = createRegionOp<Op, mlir::acc::YieldOp>( Op computeOp;
if constexpr (std::is_same_v<Op, mlir::acc::KernelsOp>)
computeOp = createRegionOp<Op, mlir::acc::TerminatorOp>(
firOpBuilder, currentLocation, operands, operandSegments);
else
computeOp = createRegionOp<Op, mlir::acc::YieldOp>(
firOpBuilder, currentLocation, operands, operandSegments); firOpBuilder, currentLocation, operands, operandSegments);
if (addAsyncAttr) if (addAsyncAttr)
computeOp.setAsyncAttrAttr(firOpBuilder.getUnitAttr()); computeOp.setAsyncAttrAttr(firOpBuilder.getUnitAttr());
if (addWaitAttr) if (addWaitAttr)
computeOp.setWaitAttrAttr(firOpBuilder.getUnitAttr()); computeOp.setWaitAttrAttr(firOpBuilder.getUnitAttr());
if (addSelfAttr) if (addSelfAttr)
computeOp.setSelfAttrAttr(firOpBuilder.getUnitAttr()); computeOp.setSelfAttrAttr(firOpBuilder.getUnitAttr());
▲ Show 20 Lines • Show All 106 Lines • ▼ Show 20 Lines createComputeOp<mlir::acc::ParallelOp>(
converter, currentLocation, semanticsContext, stmtCtx, accClauseList); converter, currentLocation, semanticsContext, stmtCtx, accClauseList);
} else if (blockDirective.v == llvm::acc::ACCD_data) { } else if (blockDirective.v == llvm::acc::ACCD_data) {
genACCDataOp(converter, currentLocation, semanticsContext, stmtCtx, genACCDataOp(converter, currentLocation, semanticsContext, stmtCtx,
accClauseList); accClauseList);
} else if (blockDirective.v == llvm::acc::ACCD_serial) { } else if (blockDirective.v == llvm::acc::ACCD_serial) {
createComputeOp<mlir::acc::SerialOp>( createComputeOp<mlir::acc::SerialOp>(
converter, currentLocation, semanticsContext, stmtCtx, accClauseList); converter, currentLocation, semanticsContext, stmtCtx, accClauseList);
} else if (blockDirective.v == llvm::acc::ACCD_kernels) { } else if (blockDirective.v == llvm::acc::ACCD_kernels) {
TODO(currentLocation, "kernels construct lowering"); createComputeOp<mlir::acc::KernelsOp>(
converter, currentLocation, semanticsContext, stmtCtx, accClauseList);
} else if (blockDirective.v == llvm::acc::ACCD_host_data) { } else if (blockDirective.v == llvm::acc::ACCD_host_data) {
TODO(currentLocation, "host_data construct lowering"); TODO(currentLocation, "host_data construct lowering");
} }
} }
static void static void
genACC(Fortran::lower::AbstractConverter &converter, genACC(Fortran::lower::AbstractConverter &converter,
Fortran::semantics::SemanticsContext &semanticsContext, Fortran::semantics::SemanticsContext &semanticsContext,
Fortran::lower::pft::Evaluation &eval, Fortran::lower::pft::Evaluation &eval,
const Fortran::parser::OpenACCCombinedConstruct &combinedConstruct) { const Fortran::parser::OpenACCCombinedConstruct &combinedConstruct) {
const auto &beginCombinedDirective = const auto &beginCombinedDirective =
std::get<Fortran::parser::AccBeginCombinedDirective>(combinedConstruct.t); std::get<Fortran::parser::AccBeginCombinedDirective>(combinedConstruct.t);
const auto &combinedDirective = const auto &combinedDirective =
std::get<Fortran::parser::AccCombinedDirective>(beginCombinedDirective.t); std::get<Fortran::parser::AccCombinedDirective>(beginCombinedDirective.t);
const auto &accClauseList = const auto &accClauseList =
std::get<Fortran::parser::AccClauseList>(beginCombinedDirective.t); std::get<Fortran::parser::AccClauseList>(beginCombinedDirective.t);
mlir::Location currentLocation = mlir::Location currentLocation =
converter.genLocation(beginCombinedDirective.source); converter.genLocation(beginCombinedDirective.source);
Fortran::lower::StatementContext stmtCtx; Fortran::lower::StatementContext stmtCtx;
if (combinedDirective.v == llvm::acc::ACCD_kernels_loop) { if (combinedDirective.v == llvm::acc::ACCD_kernels_loop) {
TODO(currentLocation, "OpenACC Kernels Loop construct not lowered yet!"); createComputeOp<mlir::acc::KernelsOp>(
converter, currentLocation, semanticsContext, stmtCtx, accClauseList);
createLoopOp(converter, currentLocation, semanticsContext, stmtCtx,
accClauseList);
} else if (combinedDirective.v == llvm::acc::ACCD_parallel_loop) { } else if (combinedDirective.v == llvm::acc::ACCD_parallel_loop) {
createComputeOp<mlir::acc::ParallelOp>( createComputeOp<mlir::acc::ParallelOp>(
converter, currentLocation, semanticsContext, stmtCtx, accClauseList); converter, currentLocation, semanticsContext, stmtCtx, accClauseList);
createLoopOp(converter, currentLocation, semanticsContext, stmtCtx, createLoopOp(converter, currentLocation, semanticsContext, stmtCtx,
accClauseList); accClauseList);
} else if (combinedDirective.v == llvm::acc::ACCD_serial_loop) { } else if (combinedDirective.v == llvm::acc::ACCD_serial_loop) {
createComputeOp<mlir::acc::SerialOp>( createComputeOp<mlir::acc::SerialOp>(
converter, currentLocation, semanticsContext, stmtCtx, accClauseList); converter, currentLocation, semanticsContext, stmtCtx, accClauseList);
▲ Show 20 Lines • Show All 436 Lines • Show Last 20 Lines

flang/test/Lower/OpenACC/acc-kernels-loop.f90

  • This file was added.
! This test checks lowering of OpenACC kernels loop combined directive.
! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s
subroutine acc_kernels_loop
integer :: i, j
integer :: async = 1
integer :: wait1 = 1
integer :: wait2 = 2
integer :: numGangs = 1
integer :: numWorkers = 10
integer :: vectorLength = 128
logical :: ifCondition = .TRUE.
integer, parameter :: n = 10
real, dimension(n) :: a, b, c
real, dimension(n, n) :: d, e
real, pointer :: f, g
integer :: gangNum = 8
integer :: gangStatic = 8
integer :: vectorNum = 128
integer, parameter :: tileSize = 2
!CHECK: [[A:%.*]] = fir.alloca !fir.array<10xf32> {{{.*}}uniq_name = "{{.*}}Ea"}
!CHECK: [[B:%.*]] = fir.alloca !fir.array<10xf32> {{{.*}}uniq_name = "{{.*}}Eb"}
!CHECK: [[C:%.*]] = fir.alloca !fir.array<10xf32> {{{.*}}uniq_name = "{{.*}}Ec"}
!CHECK: [[F:%.*]] = fir.alloca !fir.box<!fir.ptr<f32>> {bindc_name = "f", uniq_name = "{{.*}}Ef"}
!CHECK: [[G:%.*]] = fir.alloca !fir.box<!fir.ptr<f32>> {bindc_name = "g", uniq_name = "{{.*}}Eg"}
!CHECK: [[IFCONDITION:%.*]] = fir.address_of(@{{.*}}ifcondition) : !fir.ref<!fir.logical<4>>
!$acc kernels loop
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop async
DO i = 1, n
a(i) = b(i)
END DO
!$acc end kernels loop
!CHECK: acc.kernels {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: } attributes {asyncAttr}
!$acc kernels loop async(1)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[ASYNC1:%.*]] = arith.constant 1 : i32
!CHECK: acc.kernels async([[ASYNC1]] : i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop async(async)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[ASYNC2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.kernels async([[ASYNC2]] : i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop wait
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: } attributes {waitAttr}
!$acc kernels loop wait(1)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[WAIT1:%.*]] = arith.constant 1 : i32
!CHECK: acc.kernels wait([[WAIT1]] : i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop wait(1, 2)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[WAIT2:%.*]] = arith.constant 1 : i32
!CHECK: [[WAIT3:%.*]] = arith.constant 2 : i32
!CHECK: acc.kernels wait([[WAIT2]], [[WAIT3]] : i32, i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop wait(wait1, wait2)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[WAIT4:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: [[WAIT5:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.kernels wait([[WAIT4]], [[WAIT5]] : i32, i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop num_gangs(1)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[NUMGANGS1:%.*]] = arith.constant 1 : i32
!CHECK: acc.kernels num_gangs([[NUMGANGS1]] : i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop num_gangs(numGangs)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[NUMGANGS2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.kernels num_gangs([[NUMGANGS2]] : i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop num_workers(10)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[NUMWORKERS1:%.*]] = arith.constant 10 : i32
!CHECK: acc.kernels num_workers([[NUMWORKERS1]] : i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop num_workers(numWorkers)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[NUMWORKERS2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.kernels num_workers([[NUMWORKERS2]] : i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop vector_length(128)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[VECTORLENGTH1:%.*]] = arith.constant 128 : i32
!CHECK: acc.kernels vector_length([[VECTORLENGTH1]] : i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop vector_length(vectorLength)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[VECTORLENGTH2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.kernels vector_length([[VECTORLENGTH2]] : i32) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop if(.TRUE.)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[IF1:%.*]] = arith.constant true
!CHECK: acc.kernels if([[IF1]]) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop if(ifCondition)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[IFCOND:%.*]] = fir.load %{{.*}} : !fir.ref<!fir.logical<4>>
!CHECK: [[IF2:%.*]] = fir.convert [[IFCOND]] : (!fir.logical<4>) -> i1
!CHECK: acc.kernels if([[IF2]]) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop self(.TRUE.)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[SELF1:%.*]] = arith.constant true
!CHECK: acc.kernels self([[SELF1]]) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop self
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: } attributes {selfAttr}
!$acc kernels loop self(ifCondition)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: [[SELF2:%.*]] = fir.convert [[IFCONDITION]] : (!fir.ref<!fir.logical<4>>) -> i1
!CHECK: acc.kernels self([[SELF2]]) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop copy(a, b)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels copy([[A]], [[B]] : !fir.ref<!fir.array<10xf32>>, !fir.ref<!fir.array<10xf32>>) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop copy(a) copy(b)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels copy([[A]], [[B]] : !fir.ref<!fir.array<10xf32>>, !fir.ref<!fir.array<10xf32>>) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop copyin(a) copyin(readonly: b)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels copyin([[A]] : !fir.ref<!fir.array<10xf32>>) copyin_readonly([[B]] : !fir.ref<!fir.array<10xf32>>) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop copyout(a) copyout(zero: b)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels copyout([[A]] : !fir.ref<!fir.array<10xf32>>) copyout_zero([[B]] : !fir.ref<!fir.array<10xf32>>) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop create(b) create(zero: a)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels create([[B]] : !fir.ref<!fir.array<10xf32>>) create_zero([[A]] : !fir.ref<!fir.array<10xf32>>) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop no_create(a, b)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels no_create([[A]], [[B]] : !fir.ref<!fir.array<10xf32>>, !fir.ref<!fir.array<10xf32>>) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop present(a, b)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels present([[A]], [[B]] : !fir.ref<!fir.array<10xf32>>, !fir.ref<!fir.array<10xf32>>) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop deviceptr(a) deviceptr(b)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels deviceptr([[A]], [[B]] : !fir.ref<!fir.array<10xf32>>, !fir.ref<!fir.array<10xf32>>) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop attach(f, g)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels attach([[F]], [[G]] : !fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.ptr<f32>>>) {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop seq
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: } attributes {seq}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop auto
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: } attributes {auto}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop independent
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: } attributes {independent}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop gang
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop gang {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop gang(num: 8)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: [[GANGNUM1:%.*]] = arith.constant 8 : i32
!CHECK-NEXT: acc.loop gang(num=[[GANGNUM1]]: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop gang(num: gangNum)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: [[GANGNUM2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK-NEXT: acc.loop gang(num=[[GANGNUM2]]: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop gang(num: gangNum, static: gangStatic)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop gang(num=%{{.*}}: i32, static=%{{.*}}: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop vector
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop vector {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop vector(128)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: [[CONSTANT128:%.*]] = arith.constant 128 : i32
!CHECK: acc.loop vector([[CONSTANT128]]: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop vector(vectorLength)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: [[VECTORLENGTH:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.loop vector([[VECTORLENGTH]]: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop worker
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop worker {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop worker(128)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: [[WORKER128:%.*]] = arith.constant 128 : i32
!CHECK: acc.loop worker([[WORKER128]]: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop collapse(2)
DO i = 1, n
DO j = 1, n
d(i, j) = e(i, j)
END DO
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: } attributes {collapse = 2 : i64}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop
DO i = 1, n
!$acc loop
DO j = 1, n
d(i, j) = e(i, j)
END DO
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.loop {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop tile(2)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: [[TILESIZE:%.*]] = arith.constant 2 : i32
!CHECK: acc.loop tile([[TILESIZE]]: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop tile(*)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: [[TILESIZEM1:%.*]] = arith.constant -1 : i32
!CHECK: acc.loop tile([[TILESIZEM1]]: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop tile(2, 2)
DO i = 1, n
DO j = 1, n
d(i, j) = e(i, j)
END DO
END DO
!CHECK: acc.kernels {
!CHECK: [[TILESIZE1:%.*]] = arith.constant 2 : i32
!CHECK: [[TILESIZE2:%.*]] = arith.constant 2 : i32
!CHECK: acc.loop tile([[TILESIZE1]]: i32, [[TILESIZE2]]: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop tile(tileSize)
DO i = 1, n
a(i) = b(i)
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop tile(%{{.*}}: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels loop tile(tileSize, tileSize)
DO i = 1, n
DO j = 1, n
d(i, j) = e(i, j)
END DO
END DO
!CHECK: acc.kernels {
!CHECK: acc.loop tile(%{{.*}}: i32, %{{.*}}: i32) {
!CHECK: fir.do_loop
!CHECK: acc.yield
!CHECK-NEXT: }{{$}}
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
end subroutine

flang/test/Lower/OpenACC/acc-kernels.f90

  • This file was added.
! This test checks lowering of OpenACC kernels construct.
! RUN: bbc -fopenacc -emit-fir %s -o - | FileCheck %s
subroutine acc_kernels
integer :: i, j
integer :: async = 1
integer :: wait1 = 1
integer :: wait2 = 2
integer :: numGangs = 1
integer :: numWorkers = 10
integer :: vectorLength = 128
logical :: ifCondition = .TRUE.
real, dimension(10, 10) :: a, b, c
real, pointer :: d, e
!CHECK: [[A:%.*]] = fir.alloca !fir.array<10x10xf32> {{{.*}}uniq_name = "{{.*}}Ea"}
!CHECK: [[B:%.*]] = fir.alloca !fir.array<10x10xf32> {{{.*}}uniq_name = "{{.*}}Eb"}
!CHECK: [[C:%.*]] = fir.alloca !fir.array<10x10xf32> {{{.*}}uniq_name = "{{.*}}Ec"}
!CHECK: [[D:%.*]] = fir.alloca !fir.box<!fir.ptr<f32>> {bindc_name = "d", uniq_name = "{{.*}}Ed"}
!CHECK: [[E:%.*]] = fir.alloca !fir.box<!fir.ptr<f32>> {bindc_name = "e", uniq_name = "{{.*}}Ee"}
!CHECK: [[IFCONDITION:%.*]] = fir.address_of(@{{.*}}ifcondition) : !fir.ref<!fir.logical<4>>
!$acc kernels
!$acc end kernels
!CHECK: acc.kernels {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels async
!$acc end kernels
!CHECK: acc.kernels {
!CHECK: acc.terminator
!CHECK-NEXT: } attributes {asyncAttr}
!$acc kernels async(1)
!$acc end kernels
!CHECK: [[ASYNC1:%.*]] = arith.constant 1 : i32
!CHECK: acc.kernels async([[ASYNC1]] : i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels async(async)
!$acc end kernels
!CHECK: [[ASYNC2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.kernels async([[ASYNC2]] : i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels wait
!$acc end kernels
!CHECK: acc.kernels {
!CHECK: acc.terminator
!CHECK-NEXT: } attributes {waitAttr}
!$acc kernels wait(1)
!$acc end kernels
!CHECK: [[WAIT1:%.*]] = arith.constant 1 : i32
!CHECK: acc.kernels wait([[WAIT1]] : i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels wait(1, 2)
!$acc end kernels
!CHECK: [[WAIT2:%.*]] = arith.constant 1 : i32
!CHECK: [[WAIT3:%.*]] = arith.constant 2 : i32
!CHECK: acc.kernels wait([[WAIT2]], [[WAIT3]] : i32, i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels wait(wait1, wait2)
!$acc end kernels
!CHECK: [[WAIT4:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: [[WAIT5:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.kernels wait([[WAIT4]], [[WAIT5]] : i32, i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels num_gangs(1)
!$acc end kernels
!CHECK: [[NUMGANGS1:%.*]] = arith.constant 1 : i32
!CHECK: acc.kernels num_gangs([[NUMGANGS1]] : i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels num_gangs(numGangs)
!$acc end kernels
!CHECK: [[NUMGANGS2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.kernels num_gangs([[NUMGANGS2]] : i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels num_workers(10)
!$acc end kernels
!CHECK: [[NUMWORKERS1:%.*]] = arith.constant 10 : i32
!CHECK: acc.kernels num_workers([[NUMWORKERS1]] : i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels num_workers(numWorkers)
!$acc end kernels
!CHECK: [[NUMWORKERS2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.kernels num_workers([[NUMWORKERS2]] : i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels vector_length(128)
!$acc end kernels
!CHECK: [[VECTORLENGTH1:%.*]] = arith.constant 128 : i32
!CHECK: acc.kernels vector_length([[VECTORLENGTH1]] : i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels vector_length(vectorLength)
!$acc end kernels
!CHECK: [[VECTORLENGTH2:%.*]] = fir.load %{{.*}} : !fir.ref<i32>
!CHECK: acc.kernels vector_length([[VECTORLENGTH2]] : i32) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels if(.TRUE.)
!$acc end kernels
!CHECK: [[IF1:%.*]] = arith.constant true
!CHECK: acc.kernels if([[IF1]]) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels if(ifCondition)
!$acc end kernels
!CHECK: [[IFCOND:%.*]] = fir.load %{{.*}} : !fir.ref<!fir.logical<4>>
!CHECK: [[IF2:%.*]] = fir.convert [[IFCOND]] : (!fir.logical<4>) -> i1
!CHECK: acc.kernels if([[IF2]]) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels self(.TRUE.)
!$acc end kernels
!CHECK: [[SELF1:%.*]] = arith.constant true
!CHECK: acc.kernels self([[SELF1]]) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels self
!$acc end kernels
!CHECK: acc.kernels {
!CHECK: acc.terminator
!CHECK-NEXT: } attributes {selfAttr}
!$acc kernels self(ifCondition)
!$acc end kernels
!CHECK: [[SELF2:%.*]] = fir.convert [[IFCONDITION]] : (!fir.ref<!fir.logical<4>>) -> i1
!CHECK: acc.kernels self([[SELF2]]) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels copy(a, b, c)
!$acc end kernels
!CHECK: acc.kernels copy([[A]], [[B]], [[C]] : !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels copy(a) copy(b) copy(c)
!$acc end kernels
!CHECK: acc.kernels copy([[A]], [[B]], [[C]] : !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels copyin(a) copyin(readonly: b, c)
!$acc end kernels
!CHECK: acc.kernels copyin([[A]] : !fir.ref<!fir.array<10x10xf32>>) copyin_readonly([[B]], [[C]] : !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels copyout(a) copyout(zero: b) copyout(c)
!$acc end kernels
!CHECK: acc.kernels copyout([[A]], [[C]] : !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>) copyout_zero([[B]] : !fir.ref<!fir.array<10x10xf32>>) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels create(a, b) create(zero: c)
!$acc end kernels
!CHECK: acc.kernels create([[A]], [[B]] : !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>) create_zero([[C]] : !fir.ref<!fir.array<10x10xf32>>) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels no_create(a, b) create(zero: c)
!$acc end kernels
!CHECK: acc.kernels create_zero([[C]] : !fir.ref<!fir.array<10x10xf32>>) no_create([[A]], [[B]] : !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels present(a, b, c)
!$acc end kernels
!CHECK: acc.kernels present([[A]], [[B]], [[C]] : !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels deviceptr(a) deviceptr(c)
!$acc end kernels
!CHECK: acc.kernels deviceptr([[A]], [[C]] : !fir.ref<!fir.array<10x10xf32>>, !fir.ref<!fir.array<10x10xf32>>) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
!$acc kernels attach(d, e)
!$acc end kernels
!CHECK: acc.kernels attach([[D]], [[E]] : !fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.ptr<f32>>>) {
!CHECK: acc.terminator
!CHECK-NEXT: }{{$}}
end subroutine acc_kernels