offtarget 0.1.0__py3-none-any.whl

offload/_root/data/findings/oop/controls/host-private-finalization.f90

@@ -0,0 +1,51 @@
+! control for oop-assignfinal-final-private: private(x) on a host parallel construct of one thread (one change: parallel for target)
+! fortran-oop assignfinal/final-private (OpenMP 5.2, free-form Fortran):
+! private(x) of a finalizable type on a target construct: the private copy is finalized at the end
+!   of the region
+! spec: OpenMP 5.2 §5.3 p.107 l.20-22 (finalization of a privatized list item at the end of the region);
+!   Fortran 2018 7.5.6.3 (when finalization occurs); OpenMP 5.2 §1.2.6 p.19 (type-bound procedures
+!   in declare target)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 1
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type ft
+    integer :: v = 0
+  contains
+    final :: ft_fin
+  end type ft
+  integer :: fin_count = 0
+  !$omp declare target to(fin_count)
+contains
+  subroutine ft_fin(o)
+    !$omp declare target
+    type(ft), intent(inout) :: o
+    !$omp atomic update
+    fin_count = fin_count + 1
+  end subroutine ft_fin
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1
+  type(ft) :: x
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  fin_count = 0
+  !$omp target update to(fin_count)
+  !$omp parallel private(x) num_threads(1)
+  x%v = 3
+  !$omp end parallel
+  r1 = fin_count
+  ok = .true.
+  ok = ok .and. (r1 == 1)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/host-select-type.f90

@@ -0,0 +1,65 @@
+! control for oop-poly-select-type: the same calls on the host (one change: no target construct)
+! fortran-oop poly/select-type (OpenMP 5.2, free-form Fortran):
+! a declare target subroutine with a CLASS(base_t) dummy and SELECT TYPE, called on the device
+!   with mapped non-polymorphic objects of three types
+! spec: OpenMP 5.2 §1.2.6 p.19 l.1-3 (type-bound procedures accessed in a target region appear in a
+!   declare target directive); OpenMP 5.2 §7.8.1 p.205-207 (declare target, procedures); OpenMP 5.2
+!   §5.3 p.107 l.17-19 (SELECT TYPE in OpenMP regions); Fortran 2018 11.1.11 (SELECT TYPE)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 10, r2= 100, r3= -1
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type base_t
+    integer :: a = 0
+  end type base_t
+  type, extends(base_t) :: ext1
+    integer :: u = 0
+  end type ext1
+  type, extends(base_t) :: ext2
+    integer :: v = 0
+  end type ext2
+contains
+  subroutine bump(s)
+    !$omp declare target
+    class(base_t), intent(inout) :: s
+    select type (s)
+      type is (ext1)
+        s%u = s%u + 10
+      type is (ext2)
+        s%v = s%v + 100
+      class default
+        s%a = -1
+    end select
+  end subroutine bump
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2, r3
+  type(ext1) :: e1
+  type(ext2) :: e2
+  type(base_t) :: b0
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  call bump(e1)
+  call bump(e2)
+  call bump(b0)
+  r1 = e1%u
+  r2 = e2%v
+  r3 = b0%a
+  ok = .true.
+  ok = ok .and. (r1 == 10)
+  ok = ok .and. (r2 == 100)
+  ok = ok .and. (r3 == -1)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0)', 'r3= ', r3
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/parent-and-comp-component-only.f90

@@ -0,0 +1,45 @@
+! control for oop-alloccomp-parent-and-comp: the same program; one change: no map(to: x) beside map(tofrom: x%a)
+! fortran-oop alloccomp/parent-and-comp (OpenMP 5.2, free-form Fortran):
+! map(to:) of the structure and map(tofrom:) of its allocatable component on one construct
+! spec: OpenMP 5.2 §5.8.3 p.151-155 (map clause); OpenMP 5.2 §5.8.3 p.151 l.29-37 (components from the
+!   predefined default mapper); OpenMP 6.0 §B.5 p.909 l.35-37 (5.0: mapping of allocatable and
+!   pointer components); OpenMP 5.2 §5.8.3 p.156 l.6-7
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 2528
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type vec
+    integer :: n = 0
+    integer, allocatable :: a(:)
+  end type vec
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1
+  type(vec) :: x
+  integer :: i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  allocate(x%a(n))
+  x%n = n
+  do i = 1, n
+    x%a(i) = i
+  end do
+  !$omp target teams distribute parallel do map(tofrom: x%a)
+  do i = 1, n
+    x%a(i) = x%a(i) + 7
+  end do
+  r1 = sum(x%a)
+  ok = .true.
+  ok = ok .and. (r1 == 2528)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/pdt-kind.f90

@@ -0,0 +1,46 @@
+! control (fortran-oop family program oop-pdt-kind, correct on every CCE in both modes)
+! fortran-oop pdt/kind (OpenMP 5.2, free-form Fortran):
+! a derived type with a kind type parameter (integer(8) components), map(tofrom:)
+! spec: OpenMP 5.2 §5.8.3 p.151-155 (map clause); OpenMP 5.2 §5.8.3 p.155 l.5-7 (same type, type
+!   parameters and rank)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 8, r2= 36
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type kv(k)
+  integer, kind :: k = 4
+  integer(k) :: v(8)
+  end type kv
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(kv(8)) :: x
+  integer :: i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  do i = 1, 8
+    x%v(i) = int(i, 8) * 1000000000_8
+  end do
+  !$omp target map(tofrom: x)
+  do i = 1, 8
+    x%v(i) = x%v(i) + i
+  end do
+  !$omp end target
+  r1 = int(x%v(8) - 8000000000_8)
+  r2 = int(mod(sum(x%v), 1000000_8))
+  ok = .true.
+  ok = ok .and. (r1 == 8)
+  ok = ok .and. (r2 == 36)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/pdt-len-host.f90

@@ -0,0 +1,43 @@
+! control for oop-pdt-len: the same program; one change: no target construct (the PDT work runs on the host)
+! fortran-oop pdt/len (OpenMP 5.2, free-form Fortran):
+! a derived type with a length type parameter (constant), its value read on the device
+! spec: OpenMP 5.2 §5.8.3 p.151-155 (map clause); OpenMP 5.2 §5.8.3 p.155 l.5-7
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 16, r2= 1496
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type lv(m)
+  integer, len :: m
+  integer :: a(m)
+  end type lv
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(lv(16)) :: x
+  integer :: i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  do i = 1, 16
+    x%a(i) = i
+  end do
+  r1 = x%m
+  do i = 1, x%m
+    x%a(i) = x%a(i) * x%a(i)
+  end do
+  r2 = sum(x%a)
+  ok = .true.
+  ok = ok .and. (r1 == 16)
+  ok = ok .and. (r2 == 1496)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/pdt-len-unparameterized.f90

@@ -0,0 +1,46 @@
+! control for oop-pdt-len: the same program; one change: the type has no length parameter (a component m = 16 and a
+! fixed a(16) in its place; type(lv) :: x for type(lv(16)) :: x), so x%m reads the component
+! fortran-oop pdt/len (OpenMP 5.2, free-form Fortran):
+! a derived type with a length type parameter (constant), its value read on the device
+! spec: OpenMP 5.2 §5.8.3 p.151-155 (map clause); OpenMP 5.2 §5.8.3 p.155 l.5-7
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 16, r2= 1496
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type lv
+  integer :: m = 16
+  integer :: a(16)
+  end type lv
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(lv) :: x
+  integer :: i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  do i = 1, 16
+    x%a(i) = i
+  end do
+  !$omp target map(tofrom: x) map(from: r1)
+  r1 = x%m
+  do i = 1, x%m
+    x%a(i) = x%a(i) * x%a(i)
+  end do
+  !$omp end target
+  r2 = sum(x%a)
+  ok = .true.
+  ok = ok .and. (r1 == 16)
+  ok = ok .and. (r2 == 1496)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/poly-dispatch-static.f90

@@ -0,0 +1,75 @@
+! control for oop-poly-dispatch: the same program; one change: the region calls the binding on the TYPE objects
+! (statically resolved) instead of through area_of's CLASS(shape) dummy
+! fortran-oop poly/dispatch (OpenMP 5.2, free-form Fortran):
+! dynamic dispatch of a deferred binding (abstract type) through a CLASS(shape) dummy on the
+!   device
+! spec: OpenMP 5.2 §1.2.6 p.19 l.1-3 (type-bound procedures accessed in a target region appear in a
+!   declare target directive); OpenMP 5.2 §7.8.1 p.205-207 (declare target, procedures)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 29
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type, abstract :: shape
+    integer :: id = 0
+  contains
+    procedure(area_if), deferred :: area
+  end type shape
+  abstract interface
+    integer function area_if(s)
+      import :: shape
+      class(shape), intent(in) :: s
+    end function area_if
+  end interface
+  type, extends(shape) :: sq
+    integer :: side = 0
+  contains
+    procedure :: area => sq_area
+  end type sq
+  type, extends(shape) :: rect
+    integer :: w = 0, h = 0
+  contains
+    procedure :: area => rect_area
+  end type rect
+contains
+  integer function sq_area(s)
+    !$omp declare target
+    class(sq), intent(in) :: s
+    sq_area = s%side * s%side
+  end function sq_area
+  integer function rect_area(s)
+    !$omp declare target
+    class(rect), intent(in) :: s
+    rect_area = s%w * s%h
+  end function rect_area
+  integer function area_of(s)
+    !$omp declare target
+    class(shape), intent(in) :: s
+    area_of = s%area()
+  end function area_of
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1
+  type(sq) :: q
+  type(rect) :: rr
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  q%side = 3
+  rr%w = 4
+  rr%h = 5
+  !$omp target map(tofrom: q, rr) map(from: r1)
+  r1 = q%area() + rr%area()
+  !$omp end target
+  ok = .true.
+  ok = ok .and. (r1 == 29)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/section-alloc-whole-component.f90

@@ -0,0 +1,49 @@
+! control for oop-section-alloc: the same program; one change: map(tofrom: x%a) (the whole component) for the section
+! x%a(9:40)
+! fortran-oop section/alloc (OpenMP 5.2, free-form Fortran):
+! map(tofrom: x%a(9:40)): a section of an allocatable component
+! spec: OpenMP 5.2 §5.8.3 p.151 l.13 (structure elements and array sections are list items); §5.8.3
+!   p.157 l.21-22; OpenMP 5.2 §13.8 p.286 l.27-28 (other referenced elements of a mapped structure
+!   element are mapped too)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 34080, r2= 8
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type vec
+    integer :: n = 0
+    integer, allocatable :: a(:)
+  end type vec
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(vec) :: x
+  integer :: i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  allocate(x%a(n))
+  x%n = n
+  do i = 1, n
+    x%a(i) = i
+  end do
+  !$omp target teams distribute parallel do map(tofrom: x%a)
+  do i = 9, 40
+    x%a(i) = x%a(i) + 1000
+  end do
+  r1 = sum(x%a)
+  r2 = x%a(8)
+  ok = .true.
+  ok = ok .and. (r1 == 34080)
+  ok = ok .and. (r2 == 8)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/section-element-whole-array.f90

@@ -0,0 +1,50 @@
+! control for oop-section-element: the same program; one change: map(tofrom: v) (the whole array of structures, which
+! maps every element's allocatable component through the default mapper) for the section v(2)%a(5:20)
+! fortran-oop section/element (OpenMP 5.2, free-form Fortran):
+! map(tofrom: v(2)%a(5:20)): a section of the allocatable component of an array element
+! spec: OpenMP 5.2 §5.8.3 p.151 l.13 (structure elements and array sections are list items); §5.8.3
+!   p.157 l.21-22
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 2880, r2= 2080
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type vec
+    integer :: n = 0
+    integer, allocatable :: a(:)
+  end type vec
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(vec) :: v(3)
+  integer :: i, k
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  do k = 1, 3
+    allocate(v(k)%a(n))
+    v(k)%n = n
+    do i = 1, n
+      v(k)%a(i) = i
+    end do
+  end do
+  !$omp target teams distribute parallel do map(tofrom: v)
+  do i = 5, 20
+    v(2)%a(i) = v(2)%a(i) + 50
+  end do
+  r1 = sum(v(2)%a)
+  r2 = sum(v(1)%a)
+  ok = .true.
+  ok = ok .and. (r1 == 2880)
+  ok = ok .and. (r2 == 2080)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/section-element-whole-component.f90

@@ -0,0 +1,50 @@
+! control for oop-section-element: the same program; one change: map(tofrom: v(2)%a) (the whole component of the element)
+! for the section
+! fortran-oop section/element (OpenMP 5.2, free-form Fortran):
+! map(tofrom: v(2)%a(5:20)): a section of the allocatable component of an array element
+! spec: OpenMP 5.2 §5.8.3 p.151 l.13 (structure elements and array sections are list items); §5.8.3
+!   p.157 l.21-22
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 2880, r2= 2080
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type vec
+    integer :: n = 0
+    integer, allocatable :: a(:)
+  end type vec
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2
+  type(vec) :: v(3)
+  integer :: i, k
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  do k = 1, 3
+    allocate(v(k)%a(n))
+    v(k)%n = n
+    do i = 1, n
+      v(k)%a(i) = i
+    end do
+  end do
+  !$omp target teams distribute parallel do map(tofrom: v(2)%a)
+  do i = 5, 20
+    v(2)%a(i) = v(2)%a(i) + 50
+  end do
+  r1 = sum(v(2)%a)
+  r2 = sum(v(1)%a)
+  ok = .true.
+  ok = ok .and. (r1 == 2880)
+  ok = ok .and. (r2 == 2080)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/section-fixed.f90

@@ -0,0 +1,43 @@
+! control (fortran-oop family program oop-section-fixed, correct on every CCE in both modes)
+! fortran-oop section/fixed (OpenMP 5.2, free-form Fortran):
+! map(tofrom: s%b(17:48)): a section of a fixed-size array component
+! spec: OpenMP 5.2 §5.8.3 p.151 l.13 (structure elements and array sections are list items); §5.8.3
+!   p.157 l.21-22; OpenMP 5.2 §13.8 p.286 l.27-28 (other referenced elements of a mapped structure
+!   element are mapped too)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 3120
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type fs
+    integer :: b(n) = 0
+    integer :: k = 0
+  end type fs
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1
+  type(fs) :: s
+  integer :: i
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  do i = 1, n
+    s%b(i) = i
+  end do
+  !$omp target teams distribute parallel do map(tofrom: s%b(17:48))
+  do i = 17, 48
+    s%b(i) = 2 * s%b(i)
+  end do
+  r1 = sum(s%b)
+  ok = .true.
+  ok = ok .and. (r1 == 3120)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop

offload/_root/data/findings/oop/controls/tbp-override.f90

@@ -0,0 +1,64 @@
+! control (fortran-oop family program oop-tbp-override, correct on every CCE in both modes)
+! fortran-oop tbp/override (OpenMP 5.2, free-form Fortran):
+! an overridden binding called on objects of the base and the extended type, and through the
+!   parent component
+! spec: OpenMP 5.2 §1.2.6 p.19 l.1-3 (type-bound procedures accessed in a target region appear in a
+!   declare target directive); OpenMP 5.2 §7.8.1 p.205-207 (declare target, procedures)
+! legality: defined
+! expected (computed by compliance/oop_gen.py): r1= 3, r2= 405, r3= 4
+module oop_m
+  implicit none
+  integer, parameter :: n = 64
+  type base_t
+    integer :: a = 0
+  contains
+    procedure :: val => base_val
+  end type base_t
+  type, extends(base_t) :: ext_t
+    integer :: b = 0
+  contains
+    procedure :: val => ext_val
+  end type ext_t
+contains
+  integer function base_val(s)
+    !$omp declare target
+    class(base_t), intent(in) :: s
+    base_val = s%a
+  end function base_val
+  integer function ext_val(s)
+    !$omp declare target
+    class(ext_t), intent(in) :: s
+    ext_val = s%a * 100 + s%b
+  end function ext_val
+end module oop_m
+
+program oop
+  use omp_lib
+  use oop_m
+  implicit none
+  integer :: host_flag
+  logical :: ok
+  integer :: r1, r2, r3
+  type(base_t) :: b0
+  type(ext_t) :: e
+  host_flag = 1
+  !$omp target map(from: host_flag)
+  host_flag = merge(1, 0, omp_is_initial_device())
+  !$omp end target
+  b0%a = 3
+  e%a = 4
+  e%b = 5
+  !$omp target map(tofrom: b0, e) map(from: r1, r2, r3)
+  r1 = b0%val()
+  r2 = e%val()
+  r3 = e%base_t%val()
+  !$omp end target
+  ok = .true.
+  ok = ok .and. (r1 == 3)
+  ok = ok .and. (r2 == 405)
+  ok = ok .and. (r3 == 4)
+  print '(a,i0)', 'r1= ', r1
+  print '(a,i0)', 'r2= ', r2
+  print '(a,i0)', 'r3= ', r3
+  print '(a,i0,a,a)', 'RESULT ran_on_host=', host_flag, ' check=', merge('pass', 'fail', ok)
+end program oop