[OpenMP] Allocatable explicit member mapping fortran offloading tests #111190
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Created using spr 1.3.4
Member
|
@llvm/pr-subscribers-offload Author: None (agozillon) ChangesThis PR is one in a series of 3 that aim to add support for explicit member mapping of This PR provides all of the runtime tests that are currently upstreamable, unfortunately Patch is 46.76 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/111190.diff 28 Files Affected:
diff --git a/offload/test/offloading/fortran/dtype-array-constant-index-map.f90 b/offload/test/offloading/fortran/dtype-array-constant-index-map.f90
index 7e168b846f858c..ff6787012494c0 100644
--- a/offload/test/offloading/fortran/dtype-array-constant-index-map.f90
+++ b/offload/test/offloading/fortran/dtype-array-constant-index-map.f90
@@ -5,13 +5,7 @@
! test helps to check that we can replace the constants
! within the kernel with instructions and then replace
! these instructions with the kernel parameters.
-! REQUIRES: flang
-! UNSUPPORTED: nvptx64-nvidia-cuda
-! UNSUPPORTED: nvptx64-nvidia-cuda-LTO
-! UNSUPPORTED: aarch64-unknown-linux-gnu
-! UNSUPPORTED: aarch64-unknown-linux-gnu-LTO
-! UNSUPPORTED: x86_64-unknown-linux-gnu
-! UNSUPPORTED: x86_64-unknown-linux-gnu-LTO
+! REQUIRES: flang, amdgpu
! RUN: %libomptarget-compile-fortran-run-and-check-generic
module test_0
diff --git a/offload/test/offloading/fortran/dtype-member-map-syntax-1.f90 b/offload/test/offloading/fortran/dtype-member-map-syntax-1.f90
new file mode 100644
index 00000000000000..e53049e7a0c027
--- /dev/null
+++ b/offload/test/offloading/fortran/dtype-member-map-syntax-1.f90
@@ -0,0 +1,110 @@
+! This test checks a number of more complex derived type
+! member mapping syntaxes utilising a non-allocatable parent
+! derived type.
+
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+program main
+ type dtype2
+ integer int
+ real float
+ real float_elements(10)
+ end type dtype2
+
+ type dtype1
+ character (LEN=30) characters
+ character (LEN=1) character
+ type(dtype2) number
+ end type dtype1
+
+ type nonallocatabledtype
+ integer elements(20)
+ type(dtype1) num_chars
+ integer value
+ type(dtype2) internal_dtypes(5)
+ end type nonallocatabledtype
+
+ type (nonallocatabledtype) array_dtype(5)
+
+ !$omp target map(tofrom: array_dtype(5))
+ do i = 1, 20
+ array_dtype(5)%elements(i) = 20 + i
+ end do
+
+ array_dtype(5)%num_chars%number%float_elements(5) = 10
+ array_dtype(5)%value = 40
+ !$omp end target
+
+ print *, array_dtype(5)%elements
+ print *, array_dtype(5)%num_chars%number%float_elements(5)
+ print *, array_dtype(5)%value
+
+ !$omp target map(tofrom: array_dtype(4)%elements(3))
+ array_dtype(4)%elements(3) = 74
+ !$omp end target
+
+ print *, array_dtype(4)%elements(3)
+
+ !$omp target map(tofrom: array_dtype(5)%elements(3:5))
+ do i = 3, 5
+ array_dtype(5)%elements(i) = i + 1
+ end do
+ !$omp end target
+
+ do i = 3, 5
+ print *, array_dtype(5)%elements(i)
+ end do
+
+ !$omp target map(tofrom: array_dtype(3:5))
+ do i = 3, 5
+ array_dtype(i)%value = i + 2
+ end do
+ !$omp end target
+
+ do i = 3, 5
+ print *, array_dtype(i)%value
+ end do
+
+ !$omp target map(tofrom: array_dtype(4)%num_chars%number%float_elements(8))
+ array_dtype(4)%num_chars%number%float_elements(8) = 250
+ !$omp end target
+
+ print *, array_dtype(4)%num_chars%number%float_elements(8)
+
+ !$omp target map(tofrom: array_dtype(4)%num_chars%number%float_elements(5:10))
+ do i = 5, 10
+ array_dtype(4)%num_chars%number%float_elements(i) = i + 3
+ end do
+ !$omp end target
+
+ do i = 5, 10
+ print *, array_dtype(4)%num_chars%number%float_elements(i)
+ end do
+
+ !$omp target map(tofrom: array_dtype(4)%internal_dtypes(3)%float_elements(4))
+ array_dtype(4)%internal_dtypes(3)%float_elements(4) = 200
+ !$omp end target
+
+ print *, array_dtype(4)%internal_dtypes(3)%float_elements(4)
+
+end program main
+
+! CHECK: 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
+! CHECK: 10.
+! CHECK: 40
+! CHECK: 74
+! CHECK: 4
+! CHECK: 5
+! CHECK: 6
+! CHECK: 5
+! CHECK: 6
+! CHECK: 7
+! CHECK: 250.
+! CHECK: 8.
+! CHECK: 9.
+! CHECK: 10.
+! CHECK: 11.
+! CHECK: 12.
+! CHECK: 13.
+! CHECK: 200
diff --git a/offload/test/offloading/fortran/dtype-member-map-syntax-2.f90 b/offload/test/offloading/fortran/dtype-member-map-syntax-2.f90
new file mode 100644
index 00000000000000..0975794009ed24
--- /dev/null
+++ b/offload/test/offloading/fortran/dtype-member-map-syntax-2.f90
@@ -0,0 +1,176 @@
+! This test checks a number of more complex derived type
+! member mapping syntaxes utilising an allocatable parent
+! derived type and mixed allocatable members.
+
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+program main
+ implicit none
+
+ integer :: i
+ integer :: N1, N2
+
+ type :: vertexes
+ integer :: test
+ integer :: testarray(10)
+ integer(4), allocatable :: vertexx(:)
+ integer(4), allocatable :: vertexy(:)
+ end type vertexes
+
+ type testing_tile_type
+ TYPE(vertexes) :: field
+ end type testing_tile_type
+
+ type :: dtype
+ real(4) :: i
+ type(vertexes), allocatable :: vertexes(:)
+ TYPE(testing_tile_type), DIMENSION(:), allocatable :: test_tile
+ integer(4) :: array_i(10)
+ real(4) :: j
+ integer, allocatable :: array_j(:)
+ integer(4) :: k
+ end type dtype
+
+ type(dtype) :: alloca_dtype
+ type(dtype), DIMENSION(:), allocatable :: alloca_dtype_arr
+
+ allocate(alloca_dtype%vertexes(4))
+ allocate(alloca_dtype%vertexes(1)%vertexx(10))
+ allocate(alloca_dtype%vertexes(1)%vertexy(10))
+ allocate(alloca_dtype%vertexes(2)%vertexx(10))
+ allocate(alloca_dtype%vertexes(2)%vertexy(10))
+ allocate(alloca_dtype%vertexes(3)%vertexx(10))
+ allocate(alloca_dtype%vertexes(3)%vertexy(10))
+ allocate(alloca_dtype%vertexes(4)%vertexx(10))
+ allocate(alloca_dtype%vertexes(4)%vertexy(10))
+ allocate(alloca_dtype%test_tile(4))
+ allocate(alloca_dtype%test_tile(1)%field%vertexx(10))
+ allocate(alloca_dtype%test_tile(1)%field%vertexy(10))
+ allocate(alloca_dtype%test_tile(2)%field%vertexx(10))
+ allocate(alloca_dtype%test_tile(2)%field%vertexy(10))
+ allocate(alloca_dtype%test_tile(3)%field%vertexx(10))
+ allocate(alloca_dtype%test_tile(3)%field%vertexy(10))
+ allocate(alloca_dtype%test_tile(4)%field%vertexx(10))
+ allocate(alloca_dtype%test_tile(4)%field%vertexy(10))
+
+ allocate(alloca_dtype_arr(3))
+
+ N1 = 1
+ N2 = 2
+
+!$omp target map(tofrom: alloca_dtype%vertexes(N1)%test)
+ alloca_dtype%vertexes(N1)%test = 3
+!$omp end target
+
+print *, alloca_dtype%vertexes(N1)%test
+
+!$omp target map(tofrom: alloca_dtype%vertexes(N1)%test, alloca_dtype%vertexes(N2)%test)
+ alloca_dtype%vertexes(N1)%test = 5
+ alloca_dtype%vertexes(N2)%test = 10
+!$omp end target
+
+print *, alloca_dtype%vertexes(N1)%test
+print *, alloca_dtype%vertexes(N2)%test
+
+!$omp target map(tofrom: alloca_dtype%test_tile(N1)%field%vertexx, &
+!$omp alloca_dtype%test_tile(N1)%field%vertexy)
+ do i = 1, 10
+ alloca_dtype%test_tile(N1)%field%vertexx(i) = i + 4
+ alloca_dtype%test_tile(N1)%field%vertexy(i) = i + 4
+ end do
+!$omp end target
+
+print *, alloca_dtype%test_tile(N1)%field%vertexx
+print *, alloca_dtype%test_tile(N1)%field%vertexy
+
+!$omp target map(tofrom: alloca_dtype%test_tile(N1)%field%test, &
+!$omp alloca_dtype%test_tile(N2)%field%test, &
+!$omp alloca_dtype%test_tile(N1)%field%vertexy, &
+!$omp alloca_dtype%test_tile(N2)%field%vertexy)
+ alloca_dtype%test_tile(N2)%field%test = 9999
+ alloca_dtype%test_tile(N2)%field%vertexy(2) = 9998
+ alloca_dtype%test_tile(N1)%field%test = 9997
+ alloca_dtype%test_tile(N1)%field%vertexy(2) = 9996
+!$omp end target
+
+print *, alloca_dtype%test_tile(N1)%field%test
+print *, alloca_dtype%test_tile(N2)%field%test
+print *, alloca_dtype%test_tile(N1)%field%vertexy(2)
+print *, alloca_dtype%test_tile(N2)%field%vertexy(2)
+
+!$omp target map(tofrom: alloca_dtype%test_tile(N2)%field%vertexy)
+ alloca_dtype%test_tile(N2)%field%vertexy(2) = 2000
+!$omp end target
+
+!$omp target map(tofrom: alloca_dtype%vertexes(N1)%vertexx, &
+!$omp alloca_dtype%vertexes(N1)%vertexy, &
+!$omp alloca_dtype%vertexes(N2)%vertexx, &
+!$omp alloca_dtype%vertexes(N2)%vertexy)
+ do i = 1, 10
+ alloca_dtype%vertexes(N1)%vertexx(i) = i * 2
+ alloca_dtype%vertexes(N1)%vertexy(i) = i * 2
+ alloca_dtype%vertexes(N2)%vertexx(i) = i * 2
+ alloca_dtype%vertexes(N2)%vertexy(i) = i * 2
+ end do
+!$omp end target
+
+print *, alloca_dtype%vertexes(N1)%vertexx
+print *, alloca_dtype%vertexes(N1)%vertexy
+print *, alloca_dtype%vertexes(N2)%vertexx
+print *, alloca_dtype%vertexes(N2)%vertexy
+
+!$omp target map(tofrom: alloca_dtype%vertexes(N1)%vertexx, &
+!$omp alloca_dtype%vertexes(N1)%vertexy, &
+!$omp alloca_dtype%vertexes(4)%vertexy, &
+!$omp alloca_dtype%vertexes(4)%vertexx, &
+!$omp alloca_dtype%vertexes(N2)%vertexx, &
+!$omp alloca_dtype%vertexes(N2)%vertexy)
+ do i = 1, 10
+ alloca_dtype%vertexes(N1)%vertexx(i) = i * 3
+ alloca_dtype%vertexes(N1)%vertexy(i) = i * 3
+ alloca_dtype%vertexes(4)%vertexx(i) = i * 3
+ alloca_dtype%vertexes(4)%vertexy(i) = i * 3
+ alloca_dtype%vertexes(N2)%vertexx(i) = i * 3
+ alloca_dtype%vertexes(N2)%vertexy(i) = i * 3
+ end do
+!$omp end target
+
+
+ print *, alloca_dtype%vertexes(1)%vertexx
+ print *, alloca_dtype%vertexes(1)%vertexy
+ print *, alloca_dtype%vertexes(4)%vertexx
+ print *, alloca_dtype%vertexes(4)%vertexy
+ print *, alloca_dtype%vertexes(2)%vertexx
+ print *, alloca_dtype%vertexes(2)%vertexy
+
+!$omp target map(tofrom: alloca_dtype_arr(N2)%array_i)
+ do i = 1, 10
+ alloca_dtype_arr(N2)%array_i(i) = i + 2
+ end do
+!$omp end target
+
+print *, alloca_dtype_arr(N2)%array_i
+
+end program main
+
+! CHECK: 3
+! CHECK: 5
+! CHECK: 10
+! CHECK: 5 6 7 8 9 10 11 12 13 14
+! CHECK: 5 6 7 8 9 10 11 12 13 14
+! CHECK: 9997
+! CHECK: 9999
+! CHECK: 9996
+! CHECK: 9998
+! CHECK: 2 4 6 8 10 12 14 16 18 20
+! CHECK: 2 4 6 8 10 12 14 16 18 20
+! CHECK: 2 4 6 8 10 12 14 16 18 20
+! CHECK: 2 4 6 8 10 12 14 16 18 20
+! CHECK: 3 6 9 12 15 18 21 24 27 30
+! CHECK: 3 6 9 12 15 18 21 24 27 30
+! CHECK: 3 6 9 12 15 18 21 24 27 30
+! CHECK: 3 6 9 12 15 18 21 24 27 30
+! CHECK: 3 6 9 12 15 18 21 24 27 30
+! CHECK: 3 6 9 12 15 18 21 24 27 30
+! CHECK: 3 4 5 6 7 8 9 10 11 12
diff --git a/offload/test/offloading/fortran/target-map-alloca-dtype-alloca-array-of-dtype.f90 b/offload/test/offloading/fortran/target-map-alloca-dtype-alloca-array-of-dtype.f90
new file mode 100644
index 00000000000000..d0ad74d3812dc0
--- /dev/null
+++ b/offload/test/offloading/fortran/target-map-alloca-dtype-alloca-array-of-dtype.f90
@@ -0,0 +1,36 @@
+! Offloading test checking interaction of explicit
+! member mapping of an allocatable array of derived
+! types contained within an allocatable derived type
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+program main
+ type :: nested_dtype
+ real(4) :: i
+ real(4) :: j
+ integer(4) :: array_i(10)
+ integer(4) :: k
+ end type nested_dtype
+
+ type :: dtype
+ real(4) :: i
+ integer(4) :: array_i(10)
+ real(4) :: j
+ type(nested_dtype), allocatable :: array_dtype(:)
+ integer(4) :: k
+ end type dtype
+
+ type(dtype), allocatable :: dtyped
+ allocate(dtyped)
+ allocate(dtyped%array_dtype(10))
+
+!$omp target map(tofrom: dtyped%array_dtype)
+ do i = 1, 10
+ dtyped%array_dtype(i)%k = i
+ end do
+!$omp end target
+
+ print *, dtyped%array_dtype%k
+end program main
+
+!CHECK: 1 2 3 4 5 6 7 8 9 10
diff --git a/offload/test/offloading/fortran/target-map-alloca-dtype-alloca-array.f90 b/offload/test/offloading/fortran/target-map-alloca-dtype-alloca-array.f90
new file mode 100644
index 00000000000000..d48b7a10ada4c8
--- /dev/null
+++ b/offload/test/offloading/fortran/target-map-alloca-dtype-alloca-array.f90
@@ -0,0 +1,30 @@
+! Offload test that checks an allocatable array within an
+! allocatable derived type can be mapped explicitly using
+! member mapping.
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+program main
+ type :: dtype
+ real(4) :: i
+ integer(4) :: array_i(10)
+ real(4) :: j
+ integer, allocatable :: array_j(:)
+ integer(4) :: k
+ end type dtype
+
+ type(dtype), allocatable :: alloca_dtype
+ allocate(alloca_dtype)
+ allocate(alloca_dtype%array_j(10))
+
+!$omp target map(tofrom: alloca_dtype%array_j)
+ do i = 1, 10
+ alloca_dtype%array_j(i) = i
+ end do
+!$omp end target
+
+print *, alloca_dtype%array_j
+
+end program main
+
+!CHECK: 1 2 3 4 5 6 7 8 9 10
diff --git a/offload/test/offloading/fortran/target-map-alloca-dtype-and-alloca-array-v2.f90 b/offload/test/offloading/fortran/target-map-alloca-dtype-and-alloca-array-v2.f90
new file mode 100644
index 00000000000000..e54b64f074310d
--- /dev/null
+++ b/offload/test/offloading/fortran/target-map-alloca-dtype-and-alloca-array-v2.f90
@@ -0,0 +1,35 @@
+! Offload test that checks an allocatable derived type can be
+! mapped alongside one of its own allocatable components
+! without disrupting either mapping, different from original
+! as the argument ordering is reversed (similar to C++ mapping
+! of a struct and a pointer, in concept at least).
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+program main
+ type :: dtype
+ real(4) :: i
+ integer, allocatable :: scalar
+ integer(4) :: array_i(10)
+ real(4) :: j
+ integer, allocatable :: array_j(:)
+ integer(4) :: k
+ end type dtype
+
+ type(dtype), allocatable :: alloca_dtype
+ allocate(alloca_dtype)
+ allocate(alloca_dtype%array_j(10))
+
+!$omp target map(tofrom: alloca_dtype%array_j, alloca_dtype)
+ do i = 1, 10
+ alloca_dtype%array_j(i) = i
+ end do
+ alloca_dtype%k = 50
+!$omp end target
+
+print *, alloca_dtype%array_j
+print *, alloca_dtype%k
+end program main
+
+!CHECK: 1 2 3 4 5 6 7 8 9 10
+!CHECK: 50
diff --git a/offload/test/offloading/fortran/target-map-alloca-dtype-and-alloca-array.f90 b/offload/test/offloading/fortran/target-map-alloca-dtype-and-alloca-array.f90
new file mode 100644
index 00000000000000..1a147177afdd80
--- /dev/null
+++ b/offload/test/offloading/fortran/target-map-alloca-dtype-and-alloca-array.f90
@@ -0,0 +1,34 @@
+! Offload test that checks an allocatable derived type can be
+! mapped alongside one of its own allocatable components
+! without disrupting either mapping (similar to C++ mapping
+! of a struct and a pointer, in concept at least).
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+program main
+ type :: dtype
+ real(4) :: i
+ integer, allocatable :: scalar
+ integer(4) :: array_i(10)
+ real(4) :: j
+ integer, allocatable :: array_j(:)
+ integer(4) :: k
+ end type dtype
+
+ type(dtype), allocatable :: alloca_dtype
+ allocate(alloca_dtype)
+ allocate(alloca_dtype%array_j(10))
+
+!$omp target map(tofrom: alloca_dtype, alloca_dtype%array_j)
+ do i = 1, 10
+ alloca_dtype%array_j(i) = i
+ end do
+ alloca_dtype%k = 50
+!$omp end target
+
+print *, alloca_dtype%array_j
+print *, alloca_dtype%k
+end program main
+
+!CHECK: 1 2 3 4 5 6 7 8 9 10
+!CHECK: 50
diff --git a/offload/test/offloading/fortran/target-map-alloca-dtype-array-and-scalar.f90 b/offload/test/offloading/fortran/target-map-alloca-dtype-array-and-scalar.f90
new file mode 100644
index 00000000000000..63dd06f7093a7d
--- /dev/null
+++ b/offload/test/offloading/fortran/target-map-alloca-dtype-array-and-scalar.f90
@@ -0,0 +1,40 @@
+! Offloading test checking interaction of explicit
+! member mapping of non-allocatable members of an
+! allocatable derived type.
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+program main
+ type :: nested_dtype
+ real(4) :: i
+ real(4) :: j
+ integer(4) :: array_i(10)
+ integer(4) :: k
+ end type nested_dtype
+
+ type :: dtype
+ real(4) :: i
+ integer, allocatable :: scalar
+ integer(4) :: array_i(10)
+ type(nested_dtype) :: nested_dtype
+ real(4) :: j
+ integer, allocatable :: array_j(:)
+ integer(4) :: k
+ end type dtype
+
+ type(dtype), allocatable :: alloca_dtype
+ allocate(alloca_dtype)
+
+!$omp target map(tofrom: alloca_dtype%nested_dtype%array_i, alloca_dtype%k)
+ do i = 1, 10
+ alloca_dtype%nested_dtype%array_i(i) = i
+ end do
+ alloca_dtype%k = 50
+!$omp end target
+
+print *, alloca_dtype%k
+print *, alloca_dtype%nested_dtype%array_i
+end program main
+
+!CHECK: 50
+!CHECK: 1 2 3 4 5 6 7 8 9 10
diff --git a/offload/test/offloading/fortran/target-map-alloca-dtype-array-of-dtype.f90 b/offload/test/offloading/fortran/target-map-alloca-dtype-array-of-dtype.f90
new file mode 100644
index 00000000000000..327fa3575d263b
--- /dev/null
+++ b/offload/test/offloading/fortran/target-map-alloca-dtype-array-of-dtype.f90
@@ -0,0 +1,36 @@
+! Offloading test checking interaction of explicit
+! member mapping of an array of derived types
+! contained within an allocatable derived type
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+program main
+ type :: nested_dtype
+ real(4) :: i
+ real(4) :: j
+ integer(4) :: array_i(10)
+ integer(4) :: k
+ end type nested_dtype
+
+ type :: dtype
+ real(4) :: i
+ integer(4) :: array_i(10)
+ real(4) :: j
+ type(nested_dtype) :: array_dtype(10)
+ integer(4) :: k
+ end type dtype
+
+ type(dtype), allocatable :: dtyped
+ allocate(dtyped)
+
+!$omp target map(tofrom: dtyped%array_dtype)
+ do i = 1, 10
+ dtyped%array_dtype(i)%k = i
+ end do
+!$omp end target
+
+print *, dtyped%array_dtype%k
+
+end program main
+
+!CHECK: 1 2 3 4 5 6 7 8 9 10
diff --git a/offload/test/offloading/fortran/target-map-allocatable-dtype.f90 b/offload/test/offloading/fortran/target-map-allocatable-dtype.f90
new file mode 100644
index 00000000000000..27559a6c98de96
--- /dev/null
+++ b/offload/test/offloading/fortran/target-map-allocatable-dtype.f90
@@ -0,0 +1,32 @@
+! Offload test that checks an allocatable derived type can be
+! mapped and at the least non-allocatable components can be
+! accessed.
+! REQUIRES: flang, amdgpu
+
+! RUN: %libomptarget-compile-fortran-run-and-check-generic
+program main
+ type :: dtype
+ real(4) :: i
+ integer, allocatable :: scalar
+ integer(4) :: array_i(10)
+ real(4) :: j
+ integer, allocatable :: array_j(:)
+ integer(4) :: k
+ end type dtype
+
+ type(dtype), allocatable :: alloca_dtype
+ allocate(alloca_dtype)
+
+!$omp target map(tofrom: alloca_dtype)
+ do i = 1, 10
+ alloca_dtype%array_i(i) = i
+ end do
+ alloca_dtype%k = 50
+!$omp end target
+
+print *, alloca_dtype%k
+print *, alloca_dtype%array_i
+end program main
+
+!CHECK: 50
+!CHECK: 1 2 3 4 5 6 7 8 9 10
diff --git a/offload/test/offloading/fortran/target-map-double-nested-dtype-array-bounds.f90 b/offload/test/offloading/fortran/target-map-double-nested-dtype-array-bounds.f90
index 7f260ac4cdc1ed..df1d8c8b9f9af3 100644
--- a/offload/test/offloading/fortran/target-map-double-nested-dtype-array-bounds.f90
+++ b/offload/test/offloading/fortran/target-map-double-nested-dtype-array-bounds.f90
@@ -1,5 +1,5 @@
! Offloading test checking interaction of two
-! explicit arrau member maps with bounds from
+! explicit array member maps with bounds from
! two nested derived types
! REQUIRES: flang, amdgpu
diff --git a/offload/test/offloading/fortran/target-map-dtype-3d-alloca-array-with-bounds.f90 b/offload/test/offloading/fortran/target-map-dtype-3d-alloca-array-with-bounds.f90
new file mode 100644
index 00000000000000..65fa788a2296dc
--- /dev/null
+++ b/offload/test/offloading/fortran/target-map-dtype-3d-alloca-array-with-bounds.f90
@@ -0,0 +1,42 @@
+! Offload test that checks an allocatable array can be mapped with
+! a specified 3-D bounds when contained within a derived type and
+! mapped via memb...
[truncated]
|
agozillon
requested review from
DominikAdamski,
TIFitis,
dpalermo,
jhuber6,
jsjodin,
kiranchandramohan,
skatrak and
tblah
Contributor
Author
|
This is the runtime test portion of the PR stack, it's not changed particularly much from the last iteration of the PR stack other than 2 additional tests for the new "features" added. I believe previously it was already signed off and reviewed by @skatrak @TIFitis so if you're both still happy with this PRs current state, please do feel fee to approve again or otherwise leave further comments! :-) Incredibly sorry for the extra work. |
skatrak
approved these changes
Oct 22, 2024
Member
skatrak
left a comment
skatrak
left a comment
There was a problem hiding this comment.
Thank you Andrew, LGTM! One small nit is to check that some of the comments explaining the purpose of the tests seem to be split earlier than at 80 characters.
agozillon
deleted the
users/agozillon/openmp-allocatable-explicit-member-mapping-fortran-offloading-tests-1
branch
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This PR is one in a series of 3 that aim to add support for explicit member mapping of
allocatable components in derived types within OpenMP+Fortran for Flang.
This PR provides all of the runtime tests that are currently upstreamable, unfortunately
some of the other tests would require linking of the fortran runtime for offload which
we currently do not do. But regardless, this is plenty to ensure that the mapping is
working in most cases.