offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/apps/controls/cbc-integers.f90

@@ -0,0 +1,91 @@
+! Docs/findings/apps/cce20-device-link-infer-address-spaces-crash.f90: CONTROL: the index ranges as plain
+! integer module variables (declare target) instead of components of a derived-type variable. Expected and
+! observed on CCE 19, 20, 21 and AFAR (MI300A XNACK 1 and 0, MI250X): builds, bad= 0.
+module glob
+  implicit none
+  integer, parameter :: wp = kind(1.d0)
+  integer :: num_dims, num_fluids, sys_size
+  integer :: cont_end, mom_beg, mom_end
+  !$omp declare target (num_dims, num_fluids, sys_size, cont_end, mom_beg, mom_end)
+end module glob
+
+module fill
+  use glob
+  implicit none
+  ! CCE's compile-time inlining off for the two helpers: they are inlined at the device link (LTO)
+  !DIR$ INLINENEVER s_fill_density, s_fill_velocity
+contains
+  subroutine s_fill_density(L, lambda2, c, mf, drho, dp)
+    !$omp declare target
+    real(wp), dimension(sys_size), intent(inout) :: L
+    real(wp), dimension(num_fluids), intent(in) :: mf, drho
+    real(wp), intent(in) :: lambda2, c, dp
+    integer :: i
+    do i = 2, mom_beg
+      L(i) = lambda2*(c*c*drho(i - 1) - mf(i - 1)*dp)
+    end do
+  end subroutine s_fill_density
+  subroutine s_fill_velocity(L, lambda2, dvel)
+    !$omp declare target
+    real(wp), dimension(sys_size), intent(inout) :: L
+    real(wp), dimension(num_dims), intent(in) :: dvel
+    real(wp), intent(in) :: lambda2
+    integer :: i
+    do i = mom_beg + 1, mom_end
+      L(i) = lambda2*dvel(i - cont_end)
+    end do
+  end subroutine s_fill_velocity
+  subroutine s_outflow(lambda, L, c, mf, drho, dp, dvel)
+    !$omp declare target
+    real(wp), dimension(3), intent(in) :: lambda
+    real(wp), dimension(sys_size), intent(inout) :: L
+    real(wp), dimension(num_fluids), intent(in) :: mf, drho
+    real(wp), dimension(num_dims), intent(in) :: dvel
+    real(wp), intent(in) :: c, dp
+    call s_fill_density(L, lambda(2), c, mf, drho, dp)
+    call s_fill_velocity(L, lambda(2), dvel)
+  end subroutine s_outflow
+end module fill
+
+program cce20_infer_address_spaces
+  use fill
+  implicit none
+  integer, parameter :: nr = 64
+  real(wp), allocatable :: out(:, :)
+  real(wp) :: L(5), mf(2), drho(2), dvel(3)
+  real(wp) :: lambda(3), c, dp, expect
+  integer :: r, i, bad
+  num_dims = 3; num_fluids = 2
+  cont_end = num_fluids
+  mom_beg = cont_end + 1; mom_end = cont_end + num_dims
+  sys_size = mom_end
+  !$omp target update to(num_dims, num_fluids, sys_size, cont_end, mom_beg, mom_end)
+  allocate(out(sys_size, nr))
+  out = 0
+  !$omp target teams distribute parallel do private(L, mf, drho, dvel, lambda, c, dp, i) map(tofrom: out)
+  do r = 1, nr
+    do i = 1, num_fluids
+      mf(i) = 0.5_wp*i
+      drho(i) = 0.25_wp*i + r
+    end do
+    do i = 1, num_dims
+      dvel(i) = 1._wp*i + r
+    end do
+    lambda = [1._wp, 2._wp, 3._wp]
+    c = 2._wp; dp = 0.5_wp
+    L = 0
+    call s_outflow(lambda, L, c, mf, drho, dp, dvel)
+    out(:, r) = L
+  end do
+  !$omp end target teams distribute parallel do
+  bad = 0
+  do r = 1, nr
+    do i = 1, sys_size
+      expect = 0
+      if (i >= 2 .and. i <= 3) expect = 2*(4*(0.25_wp*(i - 1) + r) - 0.5_wp*(i - 1)*0.5_wp)
+      if (i >= 4) expect = 2*(1._wp*(i - 2) + r)
+      if (out(i, r) /= expect) bad = bad + 1
+    end do
+  end do
+  print '(a,i0,a,5f8.2)', 'bad= ', bad, ' out(:,1)=', out(:, 1)
+end program cce20_infer_address_spaces

offload/_root/data/findings/apps/controls/cbc-only-density.f90

@@ -0,0 +1,97 @@
+! Docs/findings/apps/cce20-device-link-infer-address-spaces-crash.f90: CONTROL: the call of
+! s_fill_velocity removed from s_outflow (only s_fill_density is called). CCE 20 -O2 links it (MI300A, data/reports/apps/
+! cce20-infer-address-spaces.txt); the unchanged check then counts the entries the removed helper fills: bad= 128.
+module glob
+  implicit none
+  integer, parameter :: wp = kind(1.d0)
+  type idx_bounds_info
+    integer :: beg
+    integer :: end
+  end type idx_bounds_info
+  type eqn_idx_info
+    type(idx_bounds_info) :: cont, mom
+  end type eqn_idx_info
+  integer :: num_dims, num_fluids, sys_size
+  type(eqn_idx_info) :: eqn_idx
+  !$omp declare target (num_dims, num_fluids, sys_size, eqn_idx)
+end module glob
+
+module fill
+  use glob
+  implicit none
+  ! CCE's compile-time inlining off for the two helpers: they are inlined at the device link (LTO)
+  !DIR$ INLINENEVER s_fill_density, s_fill_velocity
+contains
+  subroutine s_fill_density(L, lambda2, c, mf, drho, dp)
+    !$omp declare target
+    real(wp), dimension(sys_size), intent(inout) :: L
+    real(wp), dimension(num_fluids), intent(in) :: mf, drho
+    real(wp), intent(in) :: lambda2, c, dp
+    integer :: i
+    do i = 2, eqn_idx%mom%beg
+      L(i) = lambda2*(c*c*drho(i - 1) - mf(i - 1)*dp)
+    end do
+  end subroutine s_fill_density
+  subroutine s_fill_velocity(L, lambda2, dvel)
+    !$omp declare target
+    real(wp), dimension(sys_size), intent(inout) :: L
+    real(wp), dimension(num_dims), intent(in) :: dvel
+    real(wp), intent(in) :: lambda2
+    integer :: i
+    do i = eqn_idx%mom%beg + 1, eqn_idx%mom%end
+      L(i) = lambda2*dvel(i - eqn_idx%cont%end)
+    end do
+  end subroutine s_fill_velocity
+  subroutine s_outflow(lambda, L, c, mf, drho, dp, dvel)
+    !$omp declare target
+    real(wp), dimension(3), intent(in) :: lambda
+    real(wp), dimension(sys_size), intent(inout) :: L
+    real(wp), dimension(num_fluids), intent(in) :: mf, drho
+    real(wp), dimension(num_dims), intent(in) :: dvel
+    real(wp), intent(in) :: c, dp
+    call s_fill_density(L, lambda(2), c, mf, drho, dp)
+  end subroutine s_outflow
+end module fill
+
+program cce20_infer_address_spaces
+  use fill
+  implicit none
+  integer, parameter :: nr = 64
+  real(wp), allocatable :: out(:, :)
+  real(wp) :: L(5), mf(2), drho(2), dvel(3)
+  real(wp) :: lambda(3), c, dp, expect
+  integer :: r, i, bad
+  num_dims = 3; num_fluids = 2
+  eqn_idx%cont%beg = 1; eqn_idx%cont%end = num_fluids
+  eqn_idx%mom%beg = eqn_idx%cont%end + 1; eqn_idx%mom%end = eqn_idx%cont%end + num_dims
+  sys_size = eqn_idx%mom%end
+  !$omp target update to(num_dims, num_fluids, sys_size, eqn_idx)
+  allocate(out(sys_size, nr))
+  out = 0
+  !$omp target teams distribute parallel do private(L, mf, drho, dvel, lambda, c, dp, i) map(tofrom: out)
+  do r = 1, nr
+    do i = 1, num_fluids
+      mf(i) = 0.5_wp*i
+      drho(i) = 0.25_wp*i + r
+    end do
+    do i = 1, num_dims
+      dvel(i) = 1._wp*i + r
+    end do
+    lambda = [1._wp, 2._wp, 3._wp]
+    c = 2._wp; dp = 0.5_wp
+    L = 0
+    call s_outflow(lambda, L, c, mf, drho, dp, dvel)
+    out(:, r) = L
+  end do
+  !$omp end target teams distribute parallel do
+  bad = 0
+  do r = 1, nr
+    do i = 1, sys_size
+      expect = 0
+      if (i >= 2 .and. i <= 3) expect = 2*(4*(0.25_wp*(i - 1) + r) - 0.5_wp*(i - 1)*0.5_wp)
+      if (i >= 4) expect = 2*(1._wp*(i - 2) + r)
+      if (out(i, r) /= expect) bad = bad + 1
+    end do
+  end do
+  print '(a,i0,a,5f8.2)', 'bad= ', bad, ' out(:,1)=', out(:, 1)
+end program cce20_infer_address_spaces

offload/_root/data/findings/apps/controls/cbc-only-velocity.f90

@@ -0,0 +1,97 @@
+! Docs/findings/apps/cce20-device-link-infer-address-spaces-crash.f90: CONTROL: the call of
+! s_fill_density removed from s_outflow (only s_fill_velocity is called). CCE 20 -O2 links it (MI300A, data/reports/apps/
+! cce20-infer-address-spaces.txt); the unchanged check then counts the entries the removed helper fills: bad= 128.
+module glob
+  implicit none
+  integer, parameter :: wp = kind(1.d0)
+  type idx_bounds_info
+    integer :: beg
+    integer :: end
+  end type idx_bounds_info
+  type eqn_idx_info
+    type(idx_bounds_info) :: cont, mom
+  end type eqn_idx_info
+  integer :: num_dims, num_fluids, sys_size
+  type(eqn_idx_info) :: eqn_idx
+  !$omp declare target (num_dims, num_fluids, sys_size, eqn_idx)
+end module glob
+
+module fill
+  use glob
+  implicit none
+  ! CCE's compile-time inlining off for the two helpers: they are inlined at the device link (LTO)
+  !DIR$ INLINENEVER s_fill_density, s_fill_velocity
+contains
+  subroutine s_fill_density(L, lambda2, c, mf, drho, dp)
+    !$omp declare target
+    real(wp), dimension(sys_size), intent(inout) :: L
+    real(wp), dimension(num_fluids), intent(in) :: mf, drho
+    real(wp), intent(in) :: lambda2, c, dp
+    integer :: i
+    do i = 2, eqn_idx%mom%beg
+      L(i) = lambda2*(c*c*drho(i - 1) - mf(i - 1)*dp)
+    end do
+  end subroutine s_fill_density
+  subroutine s_fill_velocity(L, lambda2, dvel)
+    !$omp declare target
+    real(wp), dimension(sys_size), intent(inout) :: L
+    real(wp), dimension(num_dims), intent(in) :: dvel
+    real(wp), intent(in) :: lambda2
+    integer :: i
+    do i = eqn_idx%mom%beg + 1, eqn_idx%mom%end
+      L(i) = lambda2*dvel(i - eqn_idx%cont%end)
+    end do
+  end subroutine s_fill_velocity
+  subroutine s_outflow(lambda, L, c, mf, drho, dp, dvel)
+    !$omp declare target
+    real(wp), dimension(3), intent(in) :: lambda
+    real(wp), dimension(sys_size), intent(inout) :: L
+    real(wp), dimension(num_fluids), intent(in) :: mf, drho
+    real(wp), dimension(num_dims), intent(in) :: dvel
+    real(wp), intent(in) :: c, dp
+    call s_fill_velocity(L, lambda(2), dvel)
+  end subroutine s_outflow
+end module fill
+
+program cce20_infer_address_spaces
+  use fill
+  implicit none
+  integer, parameter :: nr = 64
+  real(wp), allocatable :: out(:, :)
+  real(wp) :: L(5), mf(2), drho(2), dvel(3)
+  real(wp) :: lambda(3), c, dp, expect
+  integer :: r, i, bad
+  num_dims = 3; num_fluids = 2
+  eqn_idx%cont%beg = 1; eqn_idx%cont%end = num_fluids
+  eqn_idx%mom%beg = eqn_idx%cont%end + 1; eqn_idx%mom%end = eqn_idx%cont%end + num_dims
+  sys_size = eqn_idx%mom%end
+  !$omp target update to(num_dims, num_fluids, sys_size, eqn_idx)
+  allocate(out(sys_size, nr))
+  out = 0
+  !$omp target teams distribute parallel do private(L, mf, drho, dvel, lambda, c, dp, i) map(tofrom: out)
+  do r = 1, nr
+    do i = 1, num_fluids
+      mf(i) = 0.5_wp*i
+      drho(i) = 0.25_wp*i + r
+    end do
+    do i = 1, num_dims
+      dvel(i) = 1._wp*i + r
+    end do
+    lambda = [1._wp, 2._wp, 3._wp]
+    c = 2._wp; dp = 0.5_wp
+    L = 0
+    call s_outflow(lambda, L, c, mf, drho, dp, dvel)
+    out(:, r) = L
+  end do
+  !$omp end target teams distribute parallel do
+  bad = 0
+  do r = 1, nr
+    do i = 1, sys_size
+      expect = 0
+      if (i >= 2 .and. i <= 3) expect = 2*(4*(0.25_wp*(i - 1) + r) - 0.5_wp*(i - 1)*0.5_wp)
+      if (i >= 4) expect = 2*(1._wp*(i - 2) + r)
+      if (out(i, r) /= expect) bad = bad + 1
+    end do
+  end do
+  print '(a,i0,a,5f8.2)', 'bad= ', bad, ' out(:,1)=', out(:, 1)
+end program cce20_infer_address_spaces

offload/_root/data/findings/apps/controls/gcc-acc-c-tile-control.c

@@ -0,0 +1,26 @@
+// Control of apps/gcc-acc-c-tile-partial-tiles-wrong.c: collapse(2) in place of tile(32, 32) (correct on gcc_g90 and gcc_sm80).
+#include <stdio.h>
+#include <stdlib.h>
+#include <openacc.h>
+
+int main(void) {
+  const int n = 100;
+  int *a = malloc(n * n * sizeof(int));
+  int bad = 0, host_flag = 1;
+  for (int k = 0; k < n * n; k++) a[k] = 0;
+#pragma acc parallel loop collapse(2) copy(a[0:n*n])
+  for (int i = 1; i < n - 1; i++)
+    for (int j = 1; j < n - 1; j++)
+      a[i * n + j] += i + j;
+#pragma acc parallel num_gangs(1) copy(host_flag)
+  host_flag = acc_on_device(acc_device_host);
+  for (int i = 0; i < n; i++)
+    for (int j = 0; j < n; j++) {
+      int want = (i > 0 && i < n - 1 && j > 0 && j < n - 1) ? i + j : 0;
+      bad += a[i * n + j] != want;
+    }
+  printf("bad= %d\n", bad);
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, bad ? "fail" : "pass");
+  free(a);
+  return 0;
+}

offload/_root/data/findings/apps/controls/gcc-acc-tile-control.f90

@@ -0,0 +1,29 @@
+! Control of apps/gcc-acc-tile-partial-tiles-wrong.f90: collapse(2) in place of tile(32, 32) (correct on gcc_g90 and gcc_sm80).
+program tile_partial
+  use openacc, only: acc_device_host, acc_on_device
+  implicit none
+  integer, parameter :: n = 100
+  integer :: a(n, n)
+  integer :: i, j, bad, want, host_flag
+  a = 0
+  !$acc parallel loop collapse(2) copy(a)
+  do j = 2, n - 1
+    do i = 2, n - 1
+      a(i, j) = a(i, j) + i + j
+    end do
+  end do
+  host_flag = 1
+  !$acc parallel num_gangs(1) copy(host_flag)
+  if (.not. acc_on_device(acc_device_host)) host_flag = 0
+  !$acc end parallel
+  bad = 0
+  do j = 1, n
+    do i = 1, n
+      want = 0
+      if (i > 1 .and. i < n .and. j > 1 .and. j < n) want = i + j
+      if (a(i, j) /= want) bad = bad + 1
+    end do
+  end do
+  print '(a,i0)', 'bad= ', bad
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', bad == 0)
+end program tile_partial

offload/_root/data/findings/apps/controls/private-array-subscript-probes.f90

@@ -0,0 +1,45 @@
+! Docs/findings/apps/cce21-private-array-loaded-subscript-wrong.f90: PROBES. z1: private v, subscript from a
+! mapped array; z2: mapped w, subscript from a declare target array; z3: private v, subscript copied from the declare
+! target array to a private scalar; z4: private v in a target region without a loop construct. Expected z1= 50 z2= 50
+! z3= 30 z4= 50 (each of 4). AFAR, CCE 19/20 (MI300A both modes): as expected. CCE 21: z1= 20, z3= 10 (wrong), z2= 50,
+! z4= 50 (correct).
+module g7
+  implicit none
+  integer :: d(3)
+  !$omp declare target (d)
+end module g7
+program dt7
+  use g7
+  implicit none
+  integer :: z1(4), z2(4), z3(4), z4(4), r, k
+  integer :: v(3), s(3), w(3)
+  d = [1, 2, 3]
+  s = [1, 2, 3]
+  w = [10, 20, 30]
+  !$omp target update to(d)
+  z1 = -1; z2 = -1; z3 = -1; z4 = -1
+  ! 1: private v, subscript from a mapped (not declare target) array
+  !$omp target parallel do map(from: z1) map(to: s) private(v)
+  do r = 1, 4
+    v = [10, 20, 30]
+    z1(r) = v(s(2)) + v(s(3))
+  end do
+  ! 2: mapped (shared) w, subscript from the declare target array
+  !$omp target parallel do map(from: z2) map(to: w)
+  do r = 1, 4
+    z2(r) = w(d(2)) + w(d(3))
+  end do
+  ! 3: private v, the declare target element first copied to a local scalar
+  !$omp target parallel do map(from: z3) private(v, k)
+  do r = 1, 4
+    v = [10, 20, 30]
+    k = d(3)
+    z3(r) = v(k)
+  end do
+  ! 4: private v, declare target subscript, in a target region without parallel do
+  !$omp target map(from: z4) private(v)
+    v = [10, 20, 30]
+    z4 = v(d(2)) + v(d(3))
+  !$omp end target
+  print '(a,4i4,a,4i4,a,4i4,a,4i4)', 'z1=', z1, ' z2=', z2, ' z3=', z3, ' z4=', z4
+end program dt7

offload/_root/data/findings/apps/controls/teams-private-array-read-par.f90

@@ -0,0 +1,31 @@
+! Docs/findings/apps/afar-cce-teams-private-array-nested-parallel-wrong.f90: PROBE: only the reading loop is a parallel do.
+! Expected bad= 0; AFAR bad= 64; CCE 19/20/21 and NVHPC bad= 0
+program teams_private_array_nested_parallel
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer :: a(n), b(n), t(0:3), i, j, jt, bad, dev
+  do i = 1, n
+    a(i) = i
+  end do
+  b = 0
+  dev = -1
+  !$omp target teams distribute private(t, j) map(to: a) map(from: b) map(tofrom: dev)
+  do jt = 1, n, 4
+    do j = 0, 3
+      t(j) = a(jt + j)
+    end do
+    !$omp parallel do
+    do j = 0, 3
+      b(jt + j) = 2*t(3 - j) + 1
+    end do
+    !$omp end parallel do
+    if (jt == 1) dev = merge(0, 1, omp_is_initial_device())
+  end do
+  !$omp end target teams distribute
+  bad = 0
+  do i = 1, n
+    if (b(i) /= 2*(2*(4*((i - 1)/4) + 1) + 3 - i) + 1) bad = bad + 1
+  end do
+  print '(a,i0,a,i0,a,4(1x,i0))', 'bad= ', bad, ' dev= ', dev, ' b(1:4)=', b(1:4)
+end program teams_private_array_nested_parallel

offload/_root/data/findings/apps/controls/teams-private-array-seq.f90

@@ -0,0 +1,30 @@
+! Docs/findings/apps/afar-cce-teams-private-array-nested-parallel-wrong.f90: CONTROL: the same loops without the two
+! parallel do directives (the team's initial thread alone writes and reads t). Expected and observed on AFAR, CCE 19/20/21 (MI300A
+! XNACK 1 and 0, MI250X) and NVHPC 25.11/26.9: bad= 0
+program teams_private_array_nested_parallel
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer :: a(n), b(n), t(0:3), i, j, jt, bad, dev
+  do i = 1, n
+    a(i) = i
+  end do
+  b = 0
+  dev = -1
+  !$omp target teams distribute private(t, j) map(to: a) map(from: b) map(tofrom: dev)
+  do jt = 1, n, 4
+    do j = 0, 3
+      t(j) = a(jt + j)
+    end do
+    do j = 0, 3
+      b(jt + j) = 2*t(3 - j) + 1
+    end do
+    if (jt == 1) dev = merge(0, 1, omp_is_initial_device())
+  end do
+  !$omp end target teams distribute
+  bad = 0
+  do i = 1, n
+    if (b(i) /= 2*(2*(4*((i - 1)/4) + 1) + 3 - i) + 1) bad = bad + 1
+  end do
+  print '(a,i0,a,i0,a,4(1x,i0))', 'bad= ', bad, ' dev= ', dev, ' b(1:4)=', b(1:4)
+end program teams_private_array_nested_parallel

offload/_root/data/findings/apps/controls/teams-private-array-shared.f90

@@ -0,0 +1,34 @@
+! Docs/findings/apps/afar-cce-teams-private-array-nested-parallel-wrong.f90: CONTROL: the same nested parallel do loops;
+! the scratch is a mapped array s(0:3, n/4) indexed by the team's iteration, not a private array. Expected and observed on AFAR, CCE
+! 19/20/21 and NVHPC 25.11/26.9: bad= 0
+program teams_private_array_nested_parallel
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer :: a(n), b(n), s(0:3, n/4), i, j, jt, bad, dev
+  do i = 1, n
+    a(i) = i
+  end do
+  b = 0
+  dev = -1
+  !$omp target teams distribute private(j) map(to: a) map(from: b) map(alloc: s) map(tofrom: dev)
+  do jt = 1, n, 4
+    !$omp parallel do
+    do j = 0, 3
+      s(j, (jt + 3)/4) = a(jt + j)
+    end do
+    !$omp end parallel do
+    !$omp parallel do
+    do j = 0, 3
+      b(jt + j) = 2*s(3 - j, (jt + 3)/4) + 1
+    end do
+    !$omp end parallel do
+    if (jt == 1) dev = merge(0, 1, omp_is_initial_device())
+  end do
+  !$omp end target teams distribute
+  bad = 0
+  do i = 1, n
+    if (b(i) /= 2*(2*(4*((i - 1)/4) + 1) + 3 - i) + 1) bad = bad + 1
+  end do
+  print '(a,i0,a,i0,a,4(1x,i0))', 'bad= ', bad, ' dev= ', dev, ' b(1:4)=', b(1:4)
+end program teams_private_array_nested_parallel

offload/_root/data/findings/apps/controls/teams-private-array-split.f90

@@ -0,0 +1,36 @@
+! Docs/findings/apps/afar-cce-teams-private-array-nested-parallel-wrong.f90: PROBE: private(t, j) on a target teams
+! construct with a separate distribute construct (private then applies to teams). Expected bad= 0; AFAR and NVHPC bad= 0; CCE 19/20
+! bad= 64, CCE 21 bad= 63
+program teams_private_array_nested_parallel
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer :: a(n), b(n), t(0:3), i, j, jt, bad, dev
+  do i = 1, n
+    a(i) = i
+  end do
+  b = 0
+  dev = -1
+  !$omp target teams private(t, j) map(to: a) map(from: b) map(tofrom: dev)
+  !$omp distribute
+  do jt = 1, n, 4
+    !$omp parallel do
+    do j = 0, 3
+      t(j) = a(jt + j)
+    end do
+    !$omp end parallel do
+    !$omp parallel do
+    do j = 0, 3
+      b(jt + j) = 2*t(3 - j) + 1
+    end do
+    !$omp end parallel do
+    if (jt == 1) dev = merge(0, 1, omp_is_initial_device())
+  end do
+  !$omp end distribute
+  !$omp end target teams
+  bad = 0
+  do i = 1, n
+    if (b(i) /= 2*(2*(4*((i - 1)/4) + 1) + 3 - i) + 1) bad = bad + 1
+  end do
+  print '(a,i0,a,i0,a,4(1x,i0))', 'bad= ', bad, ' dev= ', dev, ' b(1:4)=', b(1:4)
+end program teams_private_array_nested_parallel

offload/_root/data/findings/apps/controls/teams-private-array-write-par.f90

@@ -0,0 +1,31 @@
+! Docs/findings/apps/afar-cce-teams-private-array-nested-parallel-wrong.f90: PROBE: only the writing loop is a parallel do.
+! Expected bad= 0; AFAR, CCE 19/20 bad= 64, CCE 21 bad= 63 (MI300A, MI250X); NVHPC bad= 0
+program teams_private_array_nested_parallel
+  use omp_lib, only: omp_is_initial_device
+  implicit none
+  integer, parameter :: n = 64
+  integer :: a(n), b(n), t(0:3), i, j, jt, bad, dev
+  do i = 1, n
+    a(i) = i
+  end do
+  b = 0
+  dev = -1
+  !$omp target teams distribute private(t, j) map(to: a) map(from: b) map(tofrom: dev)
+  do jt = 1, n, 4
+    !$omp parallel do
+    do j = 0, 3
+      t(j) = a(jt + j)
+    end do
+    !$omp end parallel do
+    do j = 0, 3
+      b(jt + j) = 2*t(3 - j) + 1
+    end do
+    if (jt == 1) dev = merge(0, 1, omp_is_initial_device())
+  end do
+  !$omp end target teams distribute
+  bad = 0
+  do i = 1, n
+    if (b(i) /= 2*(2*(4*((i - 1)/4) + 1) + 3 - i) + 1) bad = bad + 1
+  end do
+  print '(a,i0,a,i0,a,4(1x,i0))', 'bad= ', bad, ' dev= ', dev, ' b(1:4)=', b(1:4)
+end program teams_private_array_nested_parallel

offload/_root/data/findings/apps/gcc-acc-c-tile-partial-tiles-wrong.c

@@ -0,0 +1,60 @@
+// # Finding (GCC 16.2, application corpus): OpenACC tile(32, 32) over loops whose trip counts are not multiples of 32 computes
+//   wrong elements
+//
+// - toolchains: gcc_g90 (GCC 16.2.0, AMD Instinct MI250X gfx90a, Tioga) and gcc_sm80 (GCC 16.2.0, NVIDIA A100 sm_80, wingtip);
+//   separate memory only; -O2
+// - build: gcc -fopenacc -foffload=amdgcn-amdhsa -foffload-options=amdgcn-amdhsa=-march=gfx90a -O2 (gcc_g90); -foffload=nvptx-none
+//   -foffload-options=nvptx-none=-march=sm_80 -foffload-options=nvptx-none=-latomic -O2 (gcc_sm80)
+// - failure: wrong_answer
+// - observed: `bad= 4342` (of the 10000 elements checked) and check=fail in every run (gcc_sm80: mandatory wrong 5 of 5; unset
+//   wrong 5 of 5; gcc_g90: mandatory wrong 5 of 5; unset wrong 5 of 5 (results/parity/<machine>/<tc>/probes.jsonl))
+// - expected: `bad= 0`, then `RESULT ran_on_host=0 check=pass`
+// - rule: "Each loop in the nest will be split, or strip-mined, into two loops, an outer tile loop and an inner element loop. The
+//   trip count of the element loop will be limited to the corresponding tile size from the size-expr-list" (OpenACC 3.4 §2.9.8
+//   l.2486-2489): tiling reorders the iterations of the nest, each still runs once. The tile clause is OpenACC 2.0's; GCC documents
+//   OpenACC 2.6.
+// - same-compiler control (correct, gcc_sm80: mandatory pass 5 of 5; unset pass 5 of 5; gcc_g90: mandatory pass 5 of 5; unset pass
+//   5 of 5 (results/parity/<machine>/<tc>/probes.jsonl)): collapse(2) in place of tile(32, 32) (controls/gcc-acc-c-tile-control.c).
+//   With trip counts of 64 (multiples of the tile size) the tiled form is correct too, and so is a one-loop tile(32) (C and
+//   Fortran, both GPUs, mandatory pass 5 of 5, unset pass 5 of 5; results/parity/probes-r2/tile_mult32.*, tile_one_loop.*).
+// - application: prk-c-stencil-acc (C1z/stencil-openacc.c, stencil_openacc.h) of the Parallel Research Kernels
+//   (data/bench/apps/manifest.yaml): its stencil kernels are `acc parallel loop tile(32,32)` over the interior of a 1000 x
+//   1000 grid;
+//   GCC's run prints `ERROR: L1 norm = 21.912356 Reference L1 norm = 22.000000`, exit 1 on both GPUs
+//   (results/parity/<machine>/results/apps/runs). NVHPC 25.11 and 26.9 validate it (results/apps/wingtip/runs).
+// - other families: NVHPC 25.11 and 26.9 run this file correctly in both memory modes (C OpenACC: no AFAR or CCE support) (site
+//   matrix). The site's finding matrix runs this file on every compiler.
+// - legality: OpenACC 3.4 §2.9.8; the nest is tightly nested and every iteration writes its own element (no race). GCC is a
+//   compiler under test only and never a legality witness.
+#include <stdio.h>
+#include <stdlib.h>
+#include <openacc.h>
+
+int main(void) {
+  const int n = 100;
+  int *a = malloc(n * n * sizeof(int));
+  int bad = 0, host_flag = 1;
+  for (int k = 0; k < n * n; k++) a[k] = 0;
+#pragma acc parallel loop tile(32, 32) copy(a[0:n*n])
+  for (int i = 1; i < n - 1; i++)
+    for (int j = 1; j < n - 1; j++)
+      a[i * n + j] += i + j;
+#pragma acc parallel num_gangs(1) copy(host_flag)
+  host_flag = acc_on_device(acc_device_host);
+  for (int i = 0; i < n; i++)
+    for (int j = 0; j < n; j++) {
+      int want = (i > 0 && i < n - 1 && j > 0 && j < n - 1) ? i + j : 0;
+      bad += a[i * n + j] != want;
+    }
+  printf("bad= %d\n", bad);
+  printf("RESULT ran_on_host=%d check=%s\n", host_flag, bad ? "fail" : "pass");
+  free(a);
+  return 0;
+}
+// site:
+// title: OpenACC tile(32, 32) over loops whose trip counts are not multiples of the tile size computes wrong elements
+// summary: A parallel loop tile(32, 32) over a 98 x 98 (or 100 x 100) nest should run every iteration once. GCC 16.2 leaves 4342 of
+// + the 10000 elements it checks wrong (C and Fortran), on the MI250X and the A100. The same nest with collapse(2), or with trip
+// + counts that are multiples of 32, is correct. Found through the Parallel Research Kernels' OpenACC stencil.
+// control: apps/controls/gcc-acc-c-tile-control.c collapse(2) in place of tile(32, 32)
+// end site