From 6954818b6f03e171110c232ce9453af3981be04a Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Tue, 6 Aug 2024 16:23:53 +0200
Subject: [PATCH 01/82] Update rocm and cce versions for both corona and tioga,
 updates of lassen specs

---
 .gitlab/jobs/corona.yml       |  4 ++--
 .gitlab/jobs/lassen.yml       | 19 ++++++++++++++-----
 .gitlab/jobs/poodle.yml       | 12 ++----------
 .gitlab/jobs/ruby.yml         | 10 ++--------
 .gitlab/jobs/tioga.yml        |  8 ++++----
 scripts/radiuss-spack-configs |  2 +-
 6 files changed, 25 insertions(+), 30 deletions(-)

diff --git a/.gitlab/jobs/corona.yml b/.gitlab/jobs/corona.yml
index abbafe5bb9..ae24d52c5d 100644
--- a/.gitlab/jobs/corona.yml
+++ b/.gitlab/jobs/corona.yml
@@ -26,9 +26,9 @@
 # ${PROJECT_<MACHINE>_DEPS} in the extra jobs. There is no reason not to fully
 # describe the spec here.
 
-rocmcc_5_7_0_hip_desul_atomics:
+rocmcc_6_0_2_hip_desul_atomics:
   variables:
-    SPEC: " ~shared +rocm ~openmp +tests +desul amdgpu_target=gfx906 %rocmcc@=5.7.0 ^hip@5.7.0 ^blt@develop"
+    SPEC: " ~shared +rocm ~openmp +tests +desul amdgpu_target=gfx906 %rocmcc@=6.0.2 ^hip@6.0.2 ^blt@develop"
   extends: .job_on_corona
 
 clang_19_0_0_sycl_gcc_10_3_1_rocmcc_5_7_1_hip:
diff --git a/.gitlab/jobs/lassen.yml b/.gitlab/jobs/lassen.yml
index dc21689ce3..bb04df7c40 100644
--- a/.gitlab/jobs/lassen.yml
+++ b/.gitlab/jobs/lassen.yml
@@ -27,6 +27,14 @@ xl_2022_08_19_gcc_8_3_1_cuda_11_2_0:
   extends: .job_on_lassen
   allow_failure: true
 
+xl_2023_06_28_gcc_11_2_1_cuda_11_8_0:
+  variables:
+    SPEC: "${PROJECT_LASSEN_VARIANTS} +cuda cxxflags==\"-qthreaded -std=c++14 -O3 -qstrict -qxlcompatmacros -qlanglvl=extended0x -qalias=noansi -qhot -qpic -qsmp=omp -qsuppress=1500-029 -qsuppress=1500-036\" %xl@=16.1.1.12.gcc.8.3.1 ^cuda@11.2.0+allow-unsupported-compilers ${PROJECT_LASSEN_DEPS} ^blt@develop"
+    MODULE_LIST: "cuda/11.8.0"
+    LASSEN_JOB_ALLOC: "1 -W 60 -q pci"
+  extends: .job_on_lassen
+  allow_failure: true
+
 ############
 # Extra jobs
 ############
@@ -39,11 +47,11 @@ gcc_8_3_1_omptask:
     SPEC: " ~shared +openmp +omptask +tests %gcc@=8.3.1 ^blt@develop"
   extends: .job_on_lassen
 
-gcc_8_3_1_cuda_11_5_0_ats_disabled:
+gcc_8_3_1_cuda_11_7_0_ats_disabled:
   extends: .job_on_lassen
   variables:
-    SPEC: " ~shared +openmp +tests +cuda %gcc@=8.3.1 cuda_arch=70 ^cuda@11.5.0+allow-unsupported-compilers ^blt@develop"
-    MODULE_LIST: "cuda/11.5.0"
+    SPEC: " ~shared +openmp +tests +cuda %gcc@=8.3.1 cuda_arch=70 ^cuda@11.7.0+allow-unsupported-compilers ^blt@develop"
+    MODULE_LIST: "cuda/11.7.0"
     LASSEN_JOB_ALLOC: "1 --atsdisable -W 30 -q pci"
 
 ##########
@@ -62,9 +70,10 @@ clang_13_0_1_libcpp:
 #    LSAN_OPTIONS: "suppressions=${CI_PROJECT_DIR}/suppressions.asan"
 #  extends: .job_on_lassen
 
-gcc_8_3_1_cuda_10_1_243_desul_atomics:
+gcc_8_3_1_cuda_11_7_desul_atomics:
   variables:
-    SPEC: " ~shared +openmp +tests +cuda +desul %gcc@=8.3.1 cuda_arch=70 ^cuda@10.1.243+allow-unsupported-compilers ^blt@develop"
+    SPEC: " ~shared +openmp +tests +cuda +desul %gcc@=8.3.1 cuda_arch=70 ^cuda@11.7.0+allow-unsupported-compilers ^blt@develop"
+    MODULE_LIST: "cuda/11.7.0"
   extends: .job_on_lassen
 
 # Warning: Allowed to fail temporarily
diff --git a/.gitlab/jobs/poodle.yml b/.gitlab/jobs/poodle.yml
index 54870e37aa..714f01b0b7 100644
--- a/.gitlab/jobs/poodle.yml
+++ b/.gitlab/jobs/poodle.yml
@@ -29,18 +29,10 @@ gcc_10_3_1:
     SPEC: " ~shared +openmp +omptask +tests %gcc@=10.3.1 ${PROJECT_POODLE_DEPS}"
   extends: .job_on_poodle
 
-# Identical to shared job, but use OpenMP tasks and no vectorization
-# Deactivated (too long on poodle)
-intel_19_1_2_gcc_10_3_1:
-  variables:
-    ON_POODLE: "OFF"
-    SPEC: " ~shared +openmp +omptask +tests %intel@=19.1.2.gcc.10.3.1 ${PROJECT_POODLE_DEPS}"
-  extends: .job_on_poodle
-
 # Allowed to fail
-intel_2022_1_0:
+intel_2023_2_1:
   variables:
-    SPEC: "${PROJECT_POODLE_VARIANTS} %intel@=2022.1.0 ${PROJECT_POODLE_DEPS}"
+    SPEC: "${PROJECT_POODLE_VARIANTS} %intel@=2023.2.1 ${PROJECT_POODLE_DEPS}"
   allow_failure: true
   extends: .job_on_poodle
 
diff --git a/.gitlab/jobs/ruby.yml b/.gitlab/jobs/ruby.yml
index 2242494b9c..49cd0d2389 100644
--- a/.gitlab/jobs/ruby.yml
+++ b/.gitlab/jobs/ruby.yml
@@ -29,16 +29,10 @@ gcc_10_3_1:
     SPEC: " ~shared +openmp +omptask +tests %gcc@=10.3.1 ${PROJECT_RUBY_DEPS}"
   extends: .job_on_ruby
 
-# Identical to shared job, but use OpenMP tasks and no vectorization
-intel_19_1_2_gcc_10_3_1:
-  variables:
-    SPEC: " ~shared +openmp +omptask +tests %intel@=19.1.2.gcc.10.3.1 ${PROJECT_RUBY_DEPS}"
-  extends: .job_on_ruby
-
 # Allowed to fail
-intel_2022_1_0:
+intel_2023_2_1:
   variables:
-    SPEC: "${PROJECT_RUBY_VARIANTS} %intel@=2022.1.0 ${PROJECT_RUBY_DEPS}"
+    SPEC: "${PROJECT_RUBY_VARIANTS} %intel@=2023.2.1 ${PROJECT_RUBY_DEPS}"
   allow_failure: true
   extends: .job_on_ruby
 
diff --git a/.gitlab/jobs/tioga.yml b/.gitlab/jobs/tioga.yml
index 50b60bc13d..8072d95791 100644
--- a/.gitlab/jobs/tioga.yml
+++ b/.gitlab/jobs/tioga.yml
@@ -26,12 +26,12 @@
 # ${PROJECT_<MACHINE>_DEPS} in the extra jobs. There is no reason not to fully
 # describe the spec here.
 
-rocmcc_6_1_1_hip_desul_atomics:
+rocmcc_6_1_2_hip_desul_atomics:
   variables:
-    SPEC: "~shared +rocm ~openmp +desul +tests amdgpu_target=gfx90a %rocmcc@=6.1.1 ^hip@6.1.1 ^blt@develop"
+    SPEC: "~shared +rocm ~openmp +desul +tests amdgpu_target=gfx90a %rocmcc@=6.1.2 ^hip@6.1.2 ^blt@develop"
   extends: .job_on_tioga
 
-rocmcc_6_1_1_hip_openmp:
+rocmcc_6_1_2_hip_openmp:
   variables:
-    SPEC: "~shared +rocm +openmp +omptask +tests amdgpu_target=gfx90a %rocmcc@=6.1.1 ^hip@6.1.1 ^blt@develop"
+    SPEC: "~shared +rocm +openmp +omptask +tests amdgpu_target=gfx90a %rocmcc@=6.1.2 ^hip@6.1.2 ^blt@develop"
   extends: .job_on_tioga
diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index 54c09b5dcf..8978ee09a0 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit 54c09b5dcf45decaac2b1e6d1048671cde17f7e5
+Subproject commit 8978ee09a0f3b70305b4c5b6eb07a6b396315030

From c7d4d4c85ed2aaab72cc9b9d69abda80c62c71af Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Tue, 6 Aug 2024 16:42:38 +0200
Subject: [PATCH 02/82] From RSC: Fix: add missing compilers and corresponding
 external packages

---
 scripts/radiuss-spack-configs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index 8978ee09a0..b0bdf60b43 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit 8978ee09a0f3b70305b4c5b6eb07a6b396315030
+Subproject commit b0bdf60b4360c3dc7a257781c7eb4775d74064dc

From 0b5e471cb65492230357cd2497c053a022cdbb15 Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Tue, 6 Aug 2024 18:36:42 +0200
Subject: [PATCH 03/82] From RSC: Deactivate rocm 5.7 job on tioga

---
 .gitlab/jobs/corona.yml       | 4 ++--
 scripts/radiuss-spack-configs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.gitlab/jobs/corona.yml b/.gitlab/jobs/corona.yml
index ae24d52c5d..9b64dbc0a4 100644
--- a/.gitlab/jobs/corona.yml
+++ b/.gitlab/jobs/corona.yml
@@ -26,9 +26,9 @@
 # ${PROJECT_<MACHINE>_DEPS} in the extra jobs. There is no reason not to fully
 # describe the spec here.
 
-rocmcc_6_0_2_hip_desul_atomics:
+rocmcc_5_7_1_hip_desul_atomics:
   variables:
-    SPEC: " ~shared +rocm ~openmp +tests +desul amdgpu_target=gfx906 %rocmcc@=6.0.2 ^hip@6.0.2 ^blt@develop"
+    SPEC: " ~shared +rocm ~openmp +tests +desul amdgpu_target=gfx906 %rocmcc@=5.7.1 ^hip@5.7.1 ^blt@develop"
   extends: .job_on_corona
 
 clang_19_0_0_sycl_gcc_10_3_1_rocmcc_5_7_1_hip:
diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index b0bdf60b43..b9739eb6c0 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit b0bdf60b4360c3dc7a257781c7eb4775d74064dc
+Subproject commit b9739eb6c050bf29ad1204354ec3afd5be6a5334

From c1170a1c9aa35e790cea763081abff7b547e5e33 Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Tue, 6 Aug 2024 18:37:07 +0200
Subject: [PATCH 04/82] From RSC: Fix: need to point at compiler wrapper with
 cuda 11.8 defined, module is not enough

---
 scripts/radiuss-spack-configs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index b9739eb6c0..7e6f52cbfe 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit b9739eb6c050bf29ad1204354ec3afd5be6a5334
+Subproject commit 7e6f52cbfe9b9a148c205e6d7bba7bf7d2e3e9d8

From b6e364517eb1bd20f2444d885a9964e6359748b8 Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Wed, 7 Aug 2024 11:33:54 +0200
Subject: [PATCH 05/82] =?UTF-8?q?From=20RSC:=20Fix:=20use=20wrapper=20with?=
 =?UTF-8?q?=20cuda=2011.8=20consistently=20+=20change=20in=20naming=20conv?=
 =?UTF-8?q?ention=20to=20match=20LC=E2=80=99s?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 scripts/radiuss-spack-configs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index 7e6f52cbfe..f0f0c1a4d0 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit 7e6f52cbfe9b9a148c205e6d7bba7bf7d2e3e9d8
+Subproject commit f0f0c1a4d02bddc1ad685cc08f6ab01c90c82900

From 919ea3b645921e1d96ead0b9e3e466ec697ca24d Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Wed, 7 Aug 2024 16:01:46 +0200
Subject: [PATCH 06/82] Do not allow intel@2023.2.1 jobs to fail on ruby and
 poodle

---
 .gitlab/jobs/poodle.yml | 7 -------
 .gitlab/jobs/ruby.yml   | 7 -------
 2 files changed, 14 deletions(-)

diff --git a/.gitlab/jobs/poodle.yml b/.gitlab/jobs/poodle.yml
index 714f01b0b7..1178dae89e 100644
--- a/.gitlab/jobs/poodle.yml
+++ b/.gitlab/jobs/poodle.yml
@@ -29,13 +29,6 @@ gcc_10_3_1:
     SPEC: " ~shared +openmp +omptask +tests %gcc@=10.3.1 ${PROJECT_POODLE_DEPS}"
   extends: .job_on_poodle
 
-# Allowed to fail
-intel_2023_2_1:
-  variables:
-    SPEC: "${PROJECT_POODLE_VARIANTS} %intel@=2023.2.1 ${PROJECT_POODLE_DEPS}"
-  allow_failure: true
-  extends: .job_on_poodle
-
 ############
 # Extra jobs
 ############
diff --git a/.gitlab/jobs/ruby.yml b/.gitlab/jobs/ruby.yml
index 49cd0d2389..458e4c7b57 100644
--- a/.gitlab/jobs/ruby.yml
+++ b/.gitlab/jobs/ruby.yml
@@ -29,13 +29,6 @@ gcc_10_3_1:
     SPEC: " ~shared +openmp +omptask +tests %gcc@=10.3.1 ${PROJECT_RUBY_DEPS}"
   extends: .job_on_ruby
 
-# Allowed to fail
-intel_2023_2_1:
-  variables:
-    SPEC: "${PROJECT_RUBY_VARIANTS} %intel@=2023.2.1 ${PROJECT_RUBY_DEPS}"
-  allow_failure: true
-  extends: .job_on_ruby
-
 ############
 # Extra jobs
 ############

From b1386d98c82cb847676e5a115ca88714a355791b Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Wed, 7 Aug 2024 16:25:44 +0200
Subject: [PATCH 07/82] From RSC: Add cuda to xl spec relying on LC wrapper
 with cuda

---
 .gitlab/jobs/lassen.yml       | 2 +-
 scripts/radiuss-spack-configs | 2 +-
 tpl/camp                      | 2 +-
 tpl/desul                     | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.gitlab/jobs/lassen.yml b/.gitlab/jobs/lassen.yml
index bb04df7c40..91980b847c 100644
--- a/.gitlab/jobs/lassen.yml
+++ b/.gitlab/jobs/lassen.yml
@@ -29,7 +29,7 @@ xl_2022_08_19_gcc_8_3_1_cuda_11_2_0:
 
 xl_2023_06_28_gcc_11_2_1_cuda_11_8_0:
   variables:
-    SPEC: "${PROJECT_LASSEN_VARIANTS} +cuda cxxflags==\"-qthreaded -std=c++14 -O3 -qstrict -qxlcompatmacros -qlanglvl=extended0x -qalias=noansi -qhot -qpic -qsmp=omp -qsuppress=1500-029 -qsuppress=1500-036\" %xl@=16.1.1.12.gcc.8.3.1 ^cuda@11.2.0+allow-unsupported-compilers ${PROJECT_LASSEN_DEPS} ^blt@develop"
+    SPEC: "${PROJECT_LASSEN_VARIANTS} +cuda cxxflags==\"-qthreaded -std=c++14 -O3 -qstrict -qxlcompatmacros -qlanglvl=extended0x -qalias=noansi -qhot -qpic -qsmp=omp -qsuppress=1500-029 -qsuppress=1500-036\" %xl@=16.1.1.12.cuda.11.8.0.gcc.8.3.1 ^cuda@11.2.0+allow-unsupported-compilers ${PROJECT_LASSEN_DEPS} ^blt@develop"
     MODULE_LIST: "cuda/11.8.0"
     LASSEN_JOB_ALLOC: "1 -W 60 -q pci"
   extends: .job_on_lassen
diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index f0f0c1a4d0..9639236da5 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit f0f0c1a4d02bddc1ad685cc08f6ab01c90c82900
+Subproject commit 9639236da58277efbcea54208ad52cf69556be8c
diff --git a/tpl/camp b/tpl/camp
index d580fd8feb..0f07de4240 160000
--- a/tpl/camp
+++ b/tpl/camp
@@ -1 +1 @@
-Subproject commit d580fd8feb10ddb7a63a784b4afcd857ac686e39
+Subproject commit 0f07de4240c42e0b38a8d872a20440cb4b33d9f5
diff --git a/tpl/desul b/tpl/desul
index 6114dd25b5..afbd4486b2 160000
--- a/tpl/desul
+++ b/tpl/desul
@@ -1 +1 @@
-Subproject commit 6114dd25b54782678c555c0c1d2197f13cc8d2a0
+Subproject commit afbd4486b2b39211e8ded3f04b12c2e0f3a25248

From 949414a9dcd1ff02a7baff918d7de2785675d268 Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Wed, 7 Aug 2024 16:53:23 +0200
Subject: [PATCH 08/82] From RSC: Fix

---
 scripts/radiuss-spack-configs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index 9639236da5..e4d5ecfe3b 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit 9639236da58277efbcea54208ad52cf69556be8c
+Subproject commit e4d5ecfe3b788b6ddfec5b963b769ac6a38193c2

From b6357a50f52170176bc20e92b71b43e43d25ed4a Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Wed, 7 Aug 2024 17:06:19 +0200
Subject: [PATCH 09/82] From RSC: Clean drop of rocm 5.7.0 in favor on 5.7.1 on
 corona

---
 scripts/radiuss-spack-configs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index e4d5ecfe3b..6e5c30da6d 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit e4d5ecfe3b788b6ddfec5b963b769ac6a38193c2
+Subproject commit 6e5c30da6d845e8772e84101e8e1a5cdd9fcb1e6

From 0260d5d76dc9b7f23b535f30f8003efa812dce47 Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Fri, 9 Aug 2024 16:08:36 +0200
Subject: [PATCH 10/82] From RSC: Update cray-mpich and add rocm 6.2.0: only
 apply cray-mpich first

---
 scripts/radiuss-spack-configs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index 6e5c30da6d..df21a7fb15 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit 6e5c30da6d845e8772e84101e8e1a5cdd9fcb1e6
+Subproject commit df21a7fb158e79e58443249cecfa5f8b90e021fe

From 81cc3282aec3f66303290483c79d95fe9f63368d Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Fri, 9 Aug 2024 16:19:17 +0200
Subject: [PATCH 11/82] Update rocm in tioga CI

---
 .gitlab/jobs/tioga.yml        | 8 ++++----
 scripts/radiuss-spack-configs | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.gitlab/jobs/tioga.yml b/.gitlab/jobs/tioga.yml
index 8072d95791..308b155ba9 100644
--- a/.gitlab/jobs/tioga.yml
+++ b/.gitlab/jobs/tioga.yml
@@ -26,12 +26,12 @@
 # ${PROJECT_<MACHINE>_DEPS} in the extra jobs. There is no reason not to fully
 # describe the spec here.
 
-rocmcc_6_1_2_hip_desul_atomics:
+rocmcc_6_2_0_hip_desul_atomics:
   variables:
-    SPEC: "~shared +rocm ~openmp +desul +tests amdgpu_target=gfx90a %rocmcc@=6.1.2 ^hip@6.1.2 ^blt@develop"
+    SPEC: "~shared +rocm ~openmp +desul +tests amdgpu_target=gfx90a %rocmcc@=6.2.0 ^hip@6.2.0 ^blt@develop"
   extends: .job_on_tioga
 
-rocmcc_6_1_2_hip_openmp:
+rocmcc_6_2_0_hip_openmp:
   variables:
-    SPEC: "~shared +rocm +openmp +omptask +tests amdgpu_target=gfx90a %rocmcc@=6.1.2 ^hip@6.1.2 ^blt@develop"
+    SPEC: "~shared +rocm +openmp +omptask +tests amdgpu_target=gfx90a %rocmcc@=6.2.0 ^hip@6.2.0 ^blt@develop"
   extends: .job_on_tioga
diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index df21a7fb15..f504356322 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit df21a7fb158e79e58443249cecfa5f8b90e021fe
+Subproject commit f504356322ca77bdb70f40c8d9d7a74a7fede822

From d9fa65edeae5d2ef73f8e9c2ebc745ac1d8c9daf Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Fri, 9 Aug 2024 23:46:12 +0200
Subject: [PATCH 12/82] From RSC: Enforce coherency between rocm software stack
 and compiler + fix

---
 scripts/radiuss-spack-configs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index f504356322..56c55b0988 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit f504356322ca77bdb70f40c8d9d7a74a7fede822
+Subproject commit 56c55b0988ec09473f3abd943c2135da138bec1c

From 9865c3d71c2252b6cb3f036d31626c3e5c497859 Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Thu, 15 Aug 2024 17:16:38 +0200
Subject: [PATCH 13/82] From RSC: Fix typo: rocm compiler is rocmcc

---
 scripts/radiuss-spack-configs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index 56c55b0988..4e8046425d 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit 56c55b0988ec09473f3abd943c2135da138bec1c
+Subproject commit 4e8046425de66ad1119ecd4f93007b00edfcc5c2

From de9f415eba6379658eab8e1ac0fe4b287247b4fc Mon Sep 17 00:00:00 2001
From: Arturo Vargas <vargas45@llnl.gov>
Date: Thu, 22 Aug 2024 16:53:34 -0700
Subject: [PATCH 14/82] intial commit for perfectly nested prototype

---
 examples/launch_reductions.cpp              | 14 +++++++-------
 include/RAJA/pattern/launch/launch_core.hpp | 19 +++++++++++++++++++
 2 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/examples/launch_reductions.cpp b/examples/launch_reductions.cpp
index 24e313e649..9a514bdc49 100644
--- a/examples/launch_reductions.cpp
+++ b/examples/launch_reductions.cpp
@@ -40,7 +40,7 @@ using device_launch = RAJA::cuda_launch_t<false>;
 using device_loop = RAJA::cuda_global_thread_x;
 #elif defined(RAJA_ENABLE_HIP)
 using device_launch = RAJA::hip_launch_t<false>;
-using device_loop = RAJA::hip_global_thread_x;
+using device_loop = RAJA::hip_thread_xyz_loop;
 #endif
 
 using launch_policy = RAJA::LaunchPolicy<host_launch
@@ -154,20 +154,20 @@ int main(int argc, char *argv[])
      RAJA::LaunchParams(RAJA::Teams(GRID_SZ),
                         RAJA::Threads(TEAM_SZ)),
      "Launch Reductions",
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx) 
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx)
      {
 
-       RAJA::loop<loop_pol>(ctx, arange, [&] (int i) {
-           
+       RAJA::expt::loop<loop_pol>(ctx, arange, arange, arange, [&] (int i, int j, int k) {
+
            kernel_sum += a[i];
-           
+
            kernel_min.min(a[i]);
            kernel_max.max(a[i]);
-           
+
            kernel_minloc.minloc(a[i], i);
            kernel_maxloc.maxloc(a[i], i);
          });
-       
+
     });
 
   std::cout << "\tsum = " << kernel_sum.get() << std::endl;
diff --git a/include/RAJA/pattern/launch/launch_core.hpp b/include/RAJA/pattern/launch/launch_core.hpp
index b78ec0de92..f1d70aeacb 100644
--- a/include/RAJA/pattern/launch/launch_core.hpp
+++ b/include/RAJA/pattern/launch/launch_core.hpp
@@ -585,6 +585,25 @@ RAJA_HOST_DEVICE RAJA_INLINE void loop(CONTEXT const &ctx,
                                                        body);
 }
 
+RAJA_SUPPRESS_HD_WARN
+template <typename POLICY_LIST,
+          typename CONTEXT,
+          typename SEGMENT,
+          typename BODY>
+RAJA_HOST_DEVICE RAJA_INLINE void loop(CONTEXT const &ctx,
+                                       SEGMENT const &segment0,
+                                       SEGMENT const &segment1,
+                                       SEGMENT const &segment2,
+                                       BODY const &body)
+{
+
+  LoopExecute<loop_policy<POLICY_LIST>, SEGMENT>::exec(ctx,
+                                                       segment0,
+                                                       segment1,
+                                                       segment2,
+                                                       body);
+}
+
 RAJA_SUPPRESS_HD_WARN
 template <typename POLICY_LIST,
           typename CONTEXT,

From 6c2152210b30c2ec13a12db76dce5c150a6caefe Mon Sep 17 00:00:00 2001
From: Arturo Vargas <vargas45@llnl.gov>
Date: Sun, 1 Sep 2024 14:20:32 -0700
Subject: [PATCH 15/82] revert changes in launch reduction examples

---
 examples/launch_reductions.cpp | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/examples/launch_reductions.cpp b/examples/launch_reductions.cpp
index 9a514bdc49..24e313e649 100644
--- a/examples/launch_reductions.cpp
+++ b/examples/launch_reductions.cpp
@@ -40,7 +40,7 @@ using device_launch = RAJA::cuda_launch_t<false>;
 using device_loop = RAJA::cuda_global_thread_x;
 #elif defined(RAJA_ENABLE_HIP)
 using device_launch = RAJA::hip_launch_t<false>;
-using device_loop = RAJA::hip_thread_xyz_loop;
+using device_loop = RAJA::hip_global_thread_x;
 #endif
 
 using launch_policy = RAJA::LaunchPolicy<host_launch
@@ -154,20 +154,20 @@ int main(int argc, char *argv[])
      RAJA::LaunchParams(RAJA::Teams(GRID_SZ),
                         RAJA::Threads(TEAM_SZ)),
      "Launch Reductions",
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx)
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx) 
      {
 
-       RAJA::expt::loop<loop_pol>(ctx, arange, arange, arange, [&] (int i, int j, int k) {
-
+       RAJA::loop<loop_pol>(ctx, arange, [&] (int i) {
+           
            kernel_sum += a[i];
-
+           
            kernel_min.min(a[i]);
            kernel_max.max(a[i]);
-
+           
            kernel_minloc.minloc(a[i], i);
            kernel_maxloc.maxloc(a[i], i);
          });
-
+       
     });
 
   std::cout << "\tsum = " << kernel_sum.get() << std::endl;

From 9161b2b57b49649f9250e8fd2457f7ade6d4f574 Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Mon, 2 Sep 2024 16:40:29 +0200
Subject: [PATCH 16/82] Allow failure for intel jobs on ruby and poodle and cce
 18 jobs on tioga, add cce 17 job on tioga

---
 .gitlab/jobs/poodle.yml |  8 ++++++++
 .gitlab/jobs/ruby.yml   |  8 ++++++++
 .gitlab/jobs/tioga.yml  | 13 ++++++++++++-
 3 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/.gitlab/jobs/poodle.yml b/.gitlab/jobs/poodle.yml
index 1178dae89e..c1fb433dbc 100644
--- a/.gitlab/jobs/poodle.yml
+++ b/.gitlab/jobs/poodle.yml
@@ -17,6 +17,14 @@
 # project. We keep ${PROJECT_<MACHINE>_VARIANTS} and ${PROJECT_<MACHINE>_DEPS}
 # when possible so that the comparison with the original job is easier.
 
+# Known issue currently under investigation
+# https://github.com/LLNL/RAJA/pull/1712#issuecomment-2292006843
+intel_2023_2_1:
+  variables:
+    SPEC: "${PROJECT_POODLE_VARIANTS} %intel@=2023.2.1 ${PROJECT_POODLE_DEPS}"
+  extends: .job_on_poodle
+  allow_failure: true
+
 # Identical to shared job, but use OpenMP tasks and no vectorization
 clang_14_0_6:
   variables:
diff --git a/.gitlab/jobs/ruby.yml b/.gitlab/jobs/ruby.yml
index 458e4c7b57..012a822b0d 100644
--- a/.gitlab/jobs/ruby.yml
+++ b/.gitlab/jobs/ruby.yml
@@ -29,6 +29,14 @@ gcc_10_3_1:
     SPEC: " ~shared +openmp +omptask +tests %gcc@=10.3.1 ${PROJECT_RUBY_DEPS}"
   extends: .job_on_ruby
 
+# Known issue currently under investigation
+# https://github.com/LLNL/RAJA/pull/1712#issuecomment-2292006843
+intel_2023_2_1:
+  variables:
+    SPEC: "${PROJECT_RUBY_VARIANTS} %intel@=2023.2.1 ${PROJECT_RUBY_DEPS}"
+  extends: .job_on_ruby
+  allow_failure: true
+
 ############
 # Extra jobs
 ############
diff --git a/.gitlab/jobs/tioga.yml b/.gitlab/jobs/tioga.yml
index 308b155ba9..b1e08cb469 100644
--- a/.gitlab/jobs/tioga.yml
+++ b/.gitlab/jobs/tioga.yml
@@ -17,7 +17,13 @@
 # project. We keep ${PROJECT_<MACHINE>_VARIANTS} and ${PROJECT_<MACHINE>_DEPS}
 # So that the comparison with the original job is easier.
 
-# No overridden jobs so far.
+# Compiler error preventing a test to succeed.
+# https://github.com/LLNL/RAJA/pull/1712#issuecomment-2316335119
+cce_18_0_0:
+  variables:
+    SPEC: "${PROJECT_TIOGA_VARIANTS} %cce@=18.0.0 ${PROJECT_TIOGA_DEPS}"
+  extends: .job_on_tioga
+  allow_failure: true
 
 ############
 # Extra jobs
@@ -26,6 +32,11 @@
 # ${PROJECT_<MACHINE>_DEPS} in the extra jobs. There is no reason not to fully
 # describe the spec here.
 
+cce_17_0_1:
+  variables:
+    SPEC: "${PROJECT_TIOGA_VARIANTS} %cce@=17.0.1 ${PROJECT_TIOGA_DEPS}"
+  extends: .job_on_tioga
+
 rocmcc_6_2_0_hip_desul_atomics:
   variables:
     SPEC: "~shared +rocm ~openmp +desul +tests amdgpu_target=gfx90a %rocmcc@=6.2.0 ^hip@6.2.0 ^blt@develop"

From f5bb9b8bb554bf5636e44a96d1abce5966392327 Mon Sep 17 00:00:00 2001
From: Arturo Vargas <vargas45@llnl.gov>
Date: Mon, 2 Sep 2024 08:48:16 -0700
Subject: [PATCH 17/82] artv3/raja-view-slowdown

---
 examples/CMakeLists.txt         |   4 +
 examples/raja_view_slowdown.cpp | 145 ++++++++++++++++++++++++++++++++
 2 files changed, 149 insertions(+)
 create mode 100644 examples/raja_view_slowdown.cpp

diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 4dfd2fbc10..fd1aed62ba 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -3,6 +3,10 @@
 # SPDX-License-Identifier: (BSD-3-Clause)
 ###############################################################################
 
+raja_add_executable(
+  NAME raja_view_slowdown
+  SOURCES raja_view_slowdown.cpp)
+
 raja_add_executable(
   NAME tut_launch_basic
   SOURCES tut_launch_basic.cpp)
diff --git a/examples/raja_view_slowdown.cpp b/examples/raja_view_slowdown.cpp
new file mode 100644
index 0000000000..7b7dc8def3
--- /dev/null
+++ b/examples/raja_view_slowdown.cpp
@@ -0,0 +1,145 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+// Copyright (c) 2016-24, Lawrence Livermore National Security, LLC
+// and RAJA project contributors. See the RAJA/LICENSE file for details.
+//
+// SPDX-License-Identifier: (BSD-3-Clause)
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+
+#include <RAJA/RAJA.hpp>
+#include "RAJA/util/Timer.hpp"
+#include <iostream>
+
+int main() {
+
+  const int N = 10000;
+  const int K = 17;
+
+  auto timer = RAJA::Timer();
+
+  //launch to intialize the stream
+  RAJA::forall<RAJA::cuda_exec<256>>
+    (RAJA::RangeSegment(0,1), [=] __device__ (int i) {
+    printf("launch kernel\n");
+  });
+
+
+  int* array = new int[N * N];
+  int* array_copy = new int[N * N];
+
+  //big array, or image
+  for (int i = 0; i < N * N; ++i) {
+    array[i] = 1;
+    array_copy[i] = 1;
+  }
+
+  //small array that acts as the blur
+  int* kernel = new int[K * K];
+  for (int i = 0; i < K * K; ++i) {
+    kernel[i] = 2;
+  }
+
+  // copying to gpu
+  int* d_array;
+  int* d_array_copy;
+  int* d_kernel;
+  cudaMalloc((void**)&d_array, N * N * sizeof(int));
+  cudaMalloc((void**)&d_array_copy, N * N * sizeof(int));
+  cudaMalloc((void**)&d_kernel, K * K * sizeof(int));
+  cudaMemcpy(d_array, array, N * N * sizeof(int), cudaMemcpyHostToDevice);
+  cudaMemcpy(d_array_copy, array_copy, N * N * sizeof(int), cudaMemcpyHostToDevice);
+  cudaMemcpy(d_kernel, kernel, K * K * sizeof(int), cudaMemcpyHostToDevice);
+
+
+  constexpr int DIM = 2;
+  RAJA::View<int, RAJA::Layout<DIM, int, 1>> array_view(d_array, N, N);
+  RAJA::View<int, RAJA::Layout<DIM, int, 1>> array_view_copy(d_array_copy, N, N);
+  RAJA::View<int, RAJA::Layout<DIM, int, 1>> kernel_view(d_kernel, K, K);
+
+
+  using EXEC_POL5 = RAJA::KernelPolicy<
+    RAJA::statement::CudaKernelFixed<256,
+      RAJA::statement::For<1, RAJA::cuda_global_size_y_direct<16>,
+        RAJA::statement::For<0, RAJA::cuda_global_size_x_direct<16>,
+	  RAJA::statement::Lambda<0>
+	  >
+       >
+     >
+    >;
+
+  RAJA::RangeSegment range_i(0, N);
+  RAJA::RangeSegment range_j(0, N);
+
+
+timer.start();
+
+  RAJA::kernel<EXEC_POL5>
+    (RAJA::make_tuple(range_i, range_j),
+     [=] RAJA_DEVICE (int i, int j) {
+      int sum = 0;
+
+      //looping through the "blur"
+      for (int m = 0; m < K; ++m) {
+	for (int n = 0; n < K; ++n) {
+	  int x = i + m;
+	  int y = j + n;
+
+	  // adding the "blur" to the "image" wherever the blur is located on the image
+	  if (x < N && y < N) {
+	    sum += kernel_view(m, n) * array_view(x, y);
+	  }
+	}
+      }
+
+      array_view(i, j) += sum;
+    }
+   );
+
+timer.stop();
+
+std::cout<<"Elapsed time with RAJA view : "<<timer.elapsed()<<std::endl;
+
+
+timer.reset();
+timer.start();
+
+  RAJA::kernel<EXEC_POL5>
+    (RAJA::make_tuple(range_i, range_j),
+     [=] RAJA_DEVICE (int i, int j) {
+      int sum = 0;
+
+      // looping through the "blur"
+      for (int m = 0; m < K; ++m) {
+	for (int n = 0; n < K; ++n) {
+	  int x = i + m;
+	  int y = j + n;
+
+	  // adding the "blur" to the "image" wherever the blur is located on the image
+	  if (x < N && y < N) {
+	    sum += d_kernel[m * K + n] * d_array_copy[x * N + y];
+	  }
+	}
+      }
+
+      d_array_copy[i * N + j] += sum;
+    }
+  );
+
+timer.stop();
+std::cout<<"Elapsed time with NO RAJA view : "<<timer.elapsed()<<std::endl;
+
+  // copy from gpu to cpu
+  cudaMemcpy(array, d_array, N * N * sizeof(int), cudaMemcpyDeviceToHost);
+  cudaMemcpy(array_copy, d_array_copy, N * N * sizeof(int), cudaMemcpyDeviceToHost);
+
+
+  cudaFree(d_array);
+  cudaFree(d_array_copy);
+  cudaFree(d_kernel);
+
+
+  delete[] array;
+  delete[] array_copy;
+  delete[] kernel;
+
+  return 0;
+}

From 0c62ada49158ff9b7c29ecb65981aecc8e1d5e10 Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Wed, 4 Sep 2024 10:29:09 +0200
Subject: [PATCH 18/82] From RSC: Remove XL jobs from shared CI jobs

---
 scripts/radiuss-spack-configs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index 4e8046425d..35c1ae0c45 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit 4e8046425de66ad1119ecd4f93007b00edfcc5c2
+Subproject commit 35c1ae0c45952c4aaccb981941572379328f4c7e

From 2a3ce5cbe38651e2f08c0091e73fff9e33125f9b Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Wed, 4 Sep 2024 11:10:02 +0200
Subject: [PATCH 19/82] Remove XL jobs defined locally too

---
 .gitlab/jobs/lassen.yml | 18 +-----------------
 1 file changed, 1 insertion(+), 17 deletions(-)

diff --git a/.gitlab/jobs/lassen.yml b/.gitlab/jobs/lassen.yml
index 91980b847c..1d4f05f038 100644
--- a/.gitlab/jobs/lassen.yml
+++ b/.gitlab/jobs/lassen.yml
@@ -17,23 +17,7 @@
 # project. We keep ${PROJECT_<MACHINE>_VARIANTS} and ${PROJECT_<MACHINE>_DEPS}
 # So that the comparison with the original job is easier.
 
-# Overriding shared spec: Longer allocation + extra flags
-# Warning: allowed to fail because of a bug in Spack > 0.20.3
-xl_2022_08_19_gcc_8_3_1_cuda_11_2_0:
-  variables:
-    SPEC: "${PROJECT_LASSEN_VARIANTS} +cuda cxxflags==\"-qthreaded -std=c++14 -O3 -qstrict -qxlcompatmacros -qlanglvl=extended0x -qalias=noansi -qhot -qpic -qsmp=omp -qsuppress=1500-029 -qsuppress=1500-036\" %xl@=16.1.1.12.gcc.8.3.1 ^cuda@11.2.0+allow-unsupported-compilers ${PROJECT_LASSEN_DEPS} ^blt@develop"
-    MODULE_LIST: "cuda/11.2.0"
-    LASSEN_JOB_ALLOC: "1 -W 60 -q pci"
-  extends: .job_on_lassen
-  allow_failure: true
-
-xl_2023_06_28_gcc_11_2_1_cuda_11_8_0:
-  variables:
-    SPEC: "${PROJECT_LASSEN_VARIANTS} +cuda cxxflags==\"-qthreaded -std=c++14 -O3 -qstrict -qxlcompatmacros -qlanglvl=extended0x -qalias=noansi -qhot -qpic -qsmp=omp -qsuppress=1500-029 -qsuppress=1500-036\" %xl@=16.1.1.12.cuda.11.8.0.gcc.8.3.1 ^cuda@11.2.0+allow-unsupported-compilers ${PROJECT_LASSEN_DEPS} ^blt@develop"
-    MODULE_LIST: "cuda/11.8.0"
-    LASSEN_JOB_ALLOC: "1 -W 60 -q pci"
-  extends: .job_on_lassen
-  allow_failure: true
+# No overridden jobs so far.
 
 ############
 # Extra jobs

From ad48eb6527cae99fd3fa2aa8c4032810368bf89f Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Thu, 5 Sep 2024 10:11:07 +0200
Subject: [PATCH 20/82] Point at main branch in RSC

---
 scripts/radiuss-spack-configs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/radiuss-spack-configs b/scripts/radiuss-spack-configs
index 35c1ae0c45..f6724f418d 160000
--- a/scripts/radiuss-spack-configs
+++ b/scripts/radiuss-spack-configs
@@ -1 +1 @@
-Subproject commit 35c1ae0c45952c4aaccb981941572379328f4c7e
+Subproject commit f6724f418d29edd1448217c817384ff54fcc7c47

From ac40ebd346e1951e78d19a1f47a8fac88df54ed4 Mon Sep 17 00:00:00 2001
From: "Adrien M. BERNEDE" <51493078+adrienbernede@users.noreply.github.com>
Date: Thu, 5 Sep 2024 21:27:00 +0200
Subject: [PATCH 21/82] Do not enforce blt@develop anymore

---
 .gitlab/custom-jobs-and-variables.yml | 10 +++++-----
 .gitlab/jobs/corona.yml               |  4 ++--
 .gitlab/jobs/lassen.yml               | 10 +++++-----
 .gitlab/jobs/poodle.yml               |  6 +++---
 .gitlab/jobs/ruby.yml                 |  6 +++---
 .gitlab/jobs/tioga.yml                |  4 ++--
 6 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/.gitlab/custom-jobs-and-variables.yml b/.gitlab/custom-jobs-and-variables.yml
index b04cf0de1d..ca6f5f9011 100644
--- a/.gitlab/custom-jobs-and-variables.yml
+++ b/.gitlab/custom-jobs-and-variables.yml
@@ -21,7 +21,7 @@ variables:
 # Project specific variants for ruby
   PROJECT_RUBY_VARIANTS: "~shared +openmp +vectorization +tests"
 # Project specific deps for ruby
-  PROJECT_RUBY_DEPS: "^blt@develop "
+  PROJECT_RUBY_DEPS:
 
 # Poodle
 # Arguments for top level allocation
@@ -31,7 +31,7 @@ variables:
 # Project specific variants for poodle
   PROJECT_POODLE_VARIANTS: "~shared +openmp +vectorization +tests"
 # Project specific deps for poodle
-  PROJECT_POODLE_DEPS: "^blt@develop "
+  PROJECT_POODLE_DEPS:
 
 # Corona
 # Arguments for top level allocation
@@ -41,7 +41,7 @@ variables:
 # Project specific variants for corona
   PROJECT_CORONA_VARIANTS: "~shared ~openmp +vectorization +tests"
 # Project specific deps for corona
-  PROJECT_CORONA_DEPS: "^blt@develop "
+  PROJECT_CORONA_DEPS:
 
 # Tioga
 # Arguments for top level allocation
@@ -51,7 +51,7 @@ variables:
 # Project specific variants for corona
   PROJECT_TIOGA_VARIANTS: "~shared +openmp +vectorization +tests"
 # Project specific deps for corona
-  PROJECT_TIOGA_DEPS: "^blt@develop "
+  PROJECT_TIOGA_DEPS:
 
 # Lassen and Butte use a different job scheduler (spectrum lsf) that does not
 # allow pre-allocation the same way slurm does.
@@ -60,7 +60,7 @@ variables:
 # Project specific variants for lassen
   PROJECT_LASSEN_VARIANTS: "~shared +openmp +vectorization +tests cuda_arch=70"
 # Project specific deps for lassen
-  PROJECT_LASSEN_DEPS: "^blt@develop "
+  PROJECT_LASSEN_DEPS:
 
 # Configuration shared by build and test jobs specific to this project.
 # Not all configuration can be shared. Here projects can fine tune the
diff --git a/.gitlab/jobs/corona.yml b/.gitlab/jobs/corona.yml
index 9b64dbc0a4..930f394f94 100644
--- a/.gitlab/jobs/corona.yml
+++ b/.gitlab/jobs/corona.yml
@@ -28,12 +28,12 @@
 
 rocmcc_5_7_1_hip_desul_atomics:
   variables:
-    SPEC: " ~shared +rocm ~openmp +tests +desul amdgpu_target=gfx906 %rocmcc@=5.7.1 ^hip@5.7.1 ^blt@develop"
+    SPEC: " ~shared +rocm ~openmp +tests +desul amdgpu_target=gfx906 %rocmcc@=5.7.1 ^hip@5.7.1"
   extends: .job_on_corona
 
 clang_19_0_0_sycl_gcc_10_3_1_rocmcc_5_7_1_hip:
   variables:
-    SPEC: " ~shared +sycl ~openmp +tests %clang@=19.0.0 cxxflags==\"-w -fsycl -fsycl-unnamed-lambda -fsycl-targets=amdgcn-amd-amdhsa -Xsycl-target-backend --offload-arch=gfx906\" ^blt@develop"
+    SPEC: " ~shared +sycl ~openmp +tests %clang@=19.0.0 cxxflags==\"-w -fsycl -fsycl-unnamed-lambda -fsycl-targets=amdgcn-amd-amdhsa -Xsycl-target-backend --offload-arch=gfx906\""
     MODULE_LIST: "rocm/5.7.1"
   extends: .job_on_corona
 
diff --git a/.gitlab/jobs/lassen.yml b/.gitlab/jobs/lassen.yml
index 1d4f05f038..2724d38a6b 100644
--- a/.gitlab/jobs/lassen.yml
+++ b/.gitlab/jobs/lassen.yml
@@ -28,13 +28,13 @@
 
 gcc_8_3_1_omptask:
   variables:
-    SPEC: " ~shared +openmp +omptask +tests %gcc@=8.3.1 ^blt@develop"
+    SPEC: " ~shared +openmp +omptask +tests %gcc@=8.3.1 ${PROJECT_LASSEN_DEPS}"
   extends: .job_on_lassen
 
 gcc_8_3_1_cuda_11_7_0_ats_disabled:
   extends: .job_on_lassen
   variables:
-    SPEC: " ~shared +openmp +tests +cuda %gcc@=8.3.1 cuda_arch=70 ^cuda@11.7.0+allow-unsupported-compilers ^blt@develop"
+    SPEC: " ~shared +openmp +tests +cuda %gcc@=8.3.1 cuda_arch=70 ^cuda@11.7.0+allow-unsupported-compilers ${PROJECT_LASSEN_DEPS}"
     MODULE_LIST: "cuda/11.7.0"
     LASSEN_JOB_ALLOC: "1 --atsdisable -W 30 -q pci"
 
@@ -44,7 +44,7 @@ gcc_8_3_1_cuda_11_7_0_ats_disabled:
 
 clang_13_0_1_libcpp:
   variables:
-    SPEC: " ~shared +openmp +tests %clang@=13.0.1 cflags==\"-DGTEST_HAS_CXXABI_H_=0\" cxxflags==\"-stdlib=libc++ -DGTEST_HAS_CXXABI_H_=0\" ^blt@develop"
+    SPEC: " ~shared +openmp +tests %clang@=13.0.1 cflags==\"-DGTEST_HAS_CXXABI_H_=0\" cxxflags==\"-stdlib=libc++ -DGTEST_HAS_CXXABI_H_=0\""
   extends: .job_on_lassen
 
 #clang_14_0_5_asan:
@@ -56,7 +56,7 @@ clang_13_0_1_libcpp:
 
 gcc_8_3_1_cuda_11_7_desul_atomics:
   variables:
-    SPEC: " ~shared +openmp +tests +cuda +desul %gcc@=8.3.1 cuda_arch=70 ^cuda@11.7.0+allow-unsupported-compilers ^blt@develop"
+    SPEC: " ~shared +openmp +tests +cuda +desul %gcc@=8.3.1 cuda_arch=70 ^cuda@11.7.0+allow-unsupported-compilers"
     MODULE_LIST: "cuda/11.7.0"
   extends: .job_on_lassen
 
@@ -64,7 +64,7 @@ gcc_8_3_1_cuda_11_7_desul_atomics:
 # Deactivated due to issues with OpenMP Target and various tests and compilers.
 clang_16_0_6_ibm_omptarget:
   variables:
-    SPEC: " ~shared +openmp +omptarget +tests %clang@=16.0.6.ibm.gcc.8.3.1 ^blt@develop"
+    SPEC: " ~shared +openmp +omptarget +tests %clang@=16.0.6.ibm.gcc.8.3.1"
     ON_LASSEN: "OFF"
   extends: .job_on_lassen
   allow_failure: true
diff --git a/.gitlab/jobs/poodle.yml b/.gitlab/jobs/poodle.yml
index c1fb433dbc..6a0b7d40df 100644
--- a/.gitlab/jobs/poodle.yml
+++ b/.gitlab/jobs/poodle.yml
@@ -46,16 +46,16 @@ gcc_10_3_1:
 
 clang_14_0_6_openmp_off:
   variables:
-    SPEC: " ~shared ~openmp +tests %clang@=14.0.6 ^blt@develop"
+    SPEC: " ~shared ~openmp +tests %clang@=14.0.6"
   extends: .job_on_poodle
 
 gcc_10_3_1_openmp_default:
   variables:
-    SPEC: " ~shared +tests %gcc@=10.3.1 ^blt@develop"
+    SPEC: " ~shared +tests %gcc@=10.3.1"
   extends: .job_on_poodle
 
 # OTHERS
 clang_14_0_6_gcc_10_3_1_desul_atomics:
   variables:
-    SPEC: " ~shared +openmp +tests +desul %clang@=14.0.6.gcc.10.3.1 ^blt@develop"
+    SPEC: " ~shared +openmp +tests +desul %clang@=14.0.6.gcc.10.3.1"
   extends: .job_on_poodle
diff --git a/.gitlab/jobs/ruby.yml b/.gitlab/jobs/ruby.yml
index 012a822b0d..dce5c43d10 100644
--- a/.gitlab/jobs/ruby.yml
+++ b/.gitlab/jobs/ruby.yml
@@ -46,16 +46,16 @@ intel_2023_2_1:
 
 clang_14_0_6_openmp_off:
   variables:
-    SPEC: " ~shared ~openmp +tests %clang@=14.0.6 ^blt@develop"
+    SPEC: " ~shared ~openmp +tests %clang@=14.0.6"
   extends: .job_on_ruby
 
 gcc_10_3_1_openmp_default:
   variables:
-    SPEC: " ~shared +tests %gcc@=10.3.1 ^blt@develop"
+    SPEC: " ~shared +tests %gcc@=10.3.1"
   extends: .job_on_ruby
 
 # OTHERS
 clang_14_0_6_gcc_10_3_1_desul_atomics:
   variables:
-    SPEC: " ~shared +openmp +tests +desul %clang@=14.0.6.gcc.10.3.1 ^blt@develop"
+    SPEC: " ~shared +openmp +tests +desul %clang@=14.0.6.gcc.10.3.1"
   extends: .job_on_ruby
diff --git a/.gitlab/jobs/tioga.yml b/.gitlab/jobs/tioga.yml
index b1e08cb469..110c8308bf 100644
--- a/.gitlab/jobs/tioga.yml
+++ b/.gitlab/jobs/tioga.yml
@@ -39,10 +39,10 @@ cce_17_0_1:
 
 rocmcc_6_2_0_hip_desul_atomics:
   variables:
-    SPEC: "~shared +rocm ~openmp +desul +tests amdgpu_target=gfx90a %rocmcc@=6.2.0 ^hip@6.2.0 ^blt@develop"
+    SPEC: "~shared +rocm ~openmp +desul +tests amdgpu_target=gfx90a %rocmcc@=6.2.0 ^hip@6.2.0"
   extends: .job_on_tioga
 
 rocmcc_6_2_0_hip_openmp:
   variables:
-    SPEC: "~shared +rocm +openmp +omptask +tests amdgpu_target=gfx90a %rocmcc@=6.2.0 ^hip@6.2.0 ^blt@develop"
+    SPEC: "~shared +rocm +openmp +omptask +tests amdgpu_target=gfx90a %rocmcc@=6.2.0 ^hip@6.2.0"
   extends: .job_on_tioga

From 3c58b7ca2fbdc39d9234219a80d17535395a2f5f Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 10:05:34 -0700
Subject: [PATCH 22/82] Add ValOp and update new reduction objects.

---
 include/RAJA/pattern/params/params_base.hpp | 102 ++++++++++++++++++
 include/RAJA/pattern/params/reducer.hpp     | 108 ++++++++------------
 2 files changed, 143 insertions(+), 67 deletions(-)

diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index 51e96260f8..b01de9c7e7 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -6,6 +6,108 @@ namespace RAJA
 {
 namespace expt
 {
+
+  template<typename T, typename IndexType = RAJA::Index_type>
+  struct ValLoc {
+    using index_type = IndexType;
+    using value_type = T;
+
+    RAJA_HOST_DEVICE constexpr ValLoc() {}
+    RAJA_HOST_DEVICE constexpr explicit ValLoc(value_type v) : val(v) {}
+    RAJA_HOST_DEVICE constexpr ValLoc(value_type v, index_type l) : val(v), loc(l) {}
+
+    RAJA_HOST_DEVICE constexpr void min(value_type v, index_type l) { if (v < val) { val = v; loc = l; } }
+
+    RAJA_HOST_DEVICE constexpr void max(value_type v, index_type l) { if (v > val) { val = v; loc = l; } }
+
+    RAJA_HOST_DEVICE constexpr bool operator<(const ValLoc& rhs) const { return val < rhs.val; }
+    RAJA_HOST_DEVICE constexpr bool operator>(const ValLoc& rhs) const { return val > rhs.val; }
+
+    RAJA_HOST_DEVICE constexpr explicit operator T() const { return val; }
+
+    RAJA_HOST_DEVICE constexpr value_type getVal() const {return val;}
+    RAJA_HOST_DEVICE constexpr index_type getLoc() const {return loc;}
+
+  //private:
+    value_type val;
+    index_type loc = -1;
+  };
+
+  template<typename T, template <typename, typename, typename> class Op>
+  struct ValOp {
+    using value_type = T;
+    using op_type = Op<T,T,T>;
+
+    RAJA_HOST_DEVICE constexpr ValOp() {}
+    RAJA_HOST_DEVICE constexpr explicit ValOp(value_type v) : val(v) {}
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & max(value_type v) { if (v > val) { val = v; } return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::plus<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & operator+=(const value_type& rhs) { val += rhs; return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::bit_and<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & operator&=(const value_type& rhs) { val &= rhs; return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::bit_or<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & operator|=(const value_type& rhs) { val |= rhs; return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::bit_and<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE ValOp & operator&=(value_type& rhs) { val &= rhs; return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::bit_or<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE ValOp & operator|=(value_type& rhs) { val |= rhs; return *this; }
+
+    RAJA_HOST_DEVICE constexpr bool operator<(const ValOp& rhs) const { val < rhs.val; return *this; }
+    RAJA_HOST_DEVICE constexpr bool operator>(const ValOp& rhs) const { val > rhs.val; return *this; }
+
+    RAJA_HOST_DEVICE constexpr value_type get() const {return val;}
+
+  //private:
+    value_type val = op_type::identity();
+  };
+
+  template<typename T, typename IndexType, template <typename, typename, typename> class Op>
+  struct ValOp <ValLoc<T,IndexType>, Op> {
+    using index_type = IndexType;
+    using value_type = ValLoc<T,index_type>;
+    using op_type = Op<value_type,value_type,value_type>;
+    using valloc_value_type = typename value_type::value_type;
+    using valloc_index_type = typename value_type::index_type;
+
+    RAJA_HOST_DEVICE constexpr ValOp() {}
+    RAJA_HOST_DEVICE constexpr explicit ValOp(value_type v) : val(v) {}
+    RAJA_HOST_DEVICE constexpr explicit ValOp(valloc_value_type v) : val(v) {}
+    RAJA_HOST_DEVICE constexpr ValOp(valloc_value_type v, valloc_index_type l) : val(v, l) {}
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<value_type,value_type,value_type>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & max(value_type v) { if (v > val) { val = v; } return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & minloc(valloc_value_type v, valloc_index_type l) { return min(value_type(v,l)); }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<value_type,value_type,value_type>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & maxloc(valloc_value_type v, valloc_index_type l) { return max(value_type(v,l)); }
+
+    RAJA_HOST_DEVICE constexpr bool operator<(const ValOp& rhs) const { return val < rhs.val; }
+    RAJA_HOST_DEVICE constexpr bool operator>(const ValOp& rhs) const { return val > rhs.val; }
+
+    RAJA_HOST_DEVICE constexpr value_type get() const {return val;}
+    RAJA_HOST_DEVICE constexpr valloc_value_type getVal() const {return val.getVal();}
+    RAJA_HOST_DEVICE constexpr valloc_index_type getLoc() const {return val.getLoc();}
+
+  //private:
+    value_type val = op_type::identity();
+  };
+
+  template<typename T, typename IndexType, template <typename, typename, typename> class Op>
+  using ValLocOp = ValOp<ValLoc<T, IndexType>, Op>;
+
 namespace detail
 {
 
diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 05103c7ad4..de1f58907a 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -15,46 +15,18 @@
 namespace RAJA
 {
 
-namespace expt
-{
-
-template<typename T>
-struct ValLoc {
-  using index_type = RAJA::Index_type;
-  using value_type = T;
-
-  RAJA_HOST_DEVICE ValLoc() {}
-  RAJA_HOST_DEVICE ValLoc(value_type v) : val(v) {}
-  RAJA_HOST_DEVICE ValLoc(value_type v, RAJA::Index_type l) : val(v), loc(l) {}
-
-  RAJA_HOST_DEVICE void min(value_type v, index_type l) { if (v < val) { val = v; loc = l; } }
-  RAJA_HOST_DEVICE void max(value_type v, index_type l) { if (v > val) { val = v; loc = l; } }
-
-  bool constexpr operator<(const ValLoc& rhs) const { return val < rhs.val; }
-  bool constexpr operator>(const ValLoc& rhs) const { return val > rhs.val; }
-
-  value_type getVal() {return val;}
-  RAJA::Index_type getLoc() {return loc;}
-
-private:
-  value_type val;
-  index_type loc = -1;
-};
-
-} //  namespace expt
-
 namespace operators
 {
 
-template <typename T>
-struct limits<RAJA::expt::ValLoc<T>> {
-  RAJA_INLINE RAJA_HOST_DEVICE static constexpr RAJA::expt::ValLoc<T> min()
+template <typename T, typename IndexType>
+struct limits<RAJA::expt::ValLoc<T, IndexType>> {
+  RAJA_INLINE RAJA_HOST_DEVICE static constexpr RAJA::expt::ValLoc<T, IndexType> min()
   {
-    return RAJA::expt::ValLoc<T>(RAJA::operators::limits<T>::min());
+    return RAJA::expt::ValLoc<T, IndexType>(RAJA::operators::limits<T>::min());
   }
-  RAJA_INLINE RAJA_HOST_DEVICE static constexpr RAJA::expt::ValLoc<T> max()
+  RAJA_INLINE RAJA_HOST_DEVICE static constexpr RAJA::expt::ValLoc<T, IndexType> max()
   {
-    return RAJA::expt::ValLoc<T>(RAJA::operators::limits<T>::max());
+    return RAJA::expt::ValLoc<T, IndexType>(RAJA::operators::limits<T>::max());
   }
 };
 
@@ -83,16 +55,31 @@ namespace detail
   // Basic Reducer
   //
   //
-  template <typename Op, typename T>
+  template <template <typename, typename, typename> class Op, typename T, typename VType, typename IndexType = RAJA::Index_type>
   struct Reducer : public ForallParamBase {
-    using op = Op;
+    using op = Op<T,T,T>;
     using value_type = T;
 
     RAJA_HOST_DEVICE Reducer() {}
-    Reducer(value_type *target_in) : target(target_in), val(op::identity()) {}
+    RAJA_HOST_DEVICE Reducer(VType *target_in) : target(target_in), val(VType{}){}
+
+    VType *target = nullptr;
+    VType val = VType{};
+
+    //template <typename U = VType, std::enable_if_t<std::is_same<U,value_type>::value>* = nullptr>
+    //RAJA_HOST_DEVICE
+    //value_type &
+    //getVal() { return val; }
+
+    template <typename U = VType, std::enable_if_t<std::is_same<U,ValOp<T,Op>>::value>* = nullptr>
+    RAJA_HOST_DEVICE
+    value_type &
+    getVal() { return val.val; }
 
-    value_type *target = nullptr;
-    value_type val = op::identity();
+    template <typename U = VType, std::enable_if_t<std::is_same<U,ValOp<ValLoc<T,IndexType>,Op>>::value>* = nullptr>
+    RAJA_HOST_DEVICE
+    value_type &
+    getVal() { return val.val.val; }
 
 #if defined(RAJA_CUDA_ACTIVE) || defined(RAJA_HIP_ACTIVE) || defined(RAJA_SYCL_ACTIVE)
     // Device related attributes.
@@ -101,7 +88,7 @@ namespace detail
     unsigned int * device_count = nullptr;
 #endif
 
-    using ARG_TUP_T = camp::tuple<value_type*>;
+    using ARG_TUP_T = camp::tuple<VType*>;
     RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&val); }
 
     using ARG_LIST_T = typename ARG_TUP_T::TList;
@@ -111,38 +98,25 @@ namespace detail
 } // namespace detail
 
 template <template <typename, typename, typename> class Op, typename T>
-auto constexpr Reduce(T *target)
+auto constexpr Reduce(ValOp<T,Op> *target)
 {
-  return detail::Reducer<Op<T, T, T>, T>(target);
+  return detail::Reducer<Op, T, ValOp<T,Op>>(target);
 }
 
+//template <template <typename, typename, typename> class Op, typename T, typename IndexType,
+//           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value>* = nullptr >
+//auto constexpr Reduce(ValLoc<T, IndexType> *target)
+//{
+//  return detail::Reducer<Op, T, ValLoc<T, IndexType>>(target);
+//}
 
+//template <template <typename, typename, typename> class Op, typename T,
+//           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value>* = nullptr >
+//auto constexpr Reduce(T *target)
+//{
+//  return detail::Reducer<Op, T, T>(target);
+//}
 
-namespace detail
-{
-
-  //
-  //
-  // Basic ReducerLoc
-  //
-  //
-  template <typename Op, typename T>
-  struct ReducerLoc : public Reducer<Op, T> {
-    using Base = Reducer<Op, T>;
-    using value_type = typename Base::value_type;
-    ReducerLoc(value_type *target_in) {
-      Base::target = target_in;
-      Base::val = value_type(Op::identity());
-    }
-  };
-
-} // namespace detail
-
-template <template <typename, typename, typename> class Op, typename T>
-auto constexpr ReduceLoc(T *target)
-{
-  return detail::ReducerLoc<Op<T, T, T>, T>(target);
-}
 } // namespace expt
 
 

From 04acb5a1e6473a0e7ca538a08f89855e9f49167f Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 10:06:07 -0700
Subject: [PATCH 23/82] Update CUDA grid_reduce for ValOp.

---
 include/RAJA/policy/cuda/reduce.hpp | 71 +++++++++++++++++++++++++----
 1 file changed, 61 insertions(+), 10 deletions(-)

diff --git a/include/RAJA/policy/cuda/reduce.hpp b/include/RAJA/policy/cuda/reduce.hpp
index 8d55698af8..670051f4e3 100644
--- a/include/RAJA/policy/cuda/reduce.hpp
+++ b/include/RAJA/policy/cuda/reduce.hpp
@@ -200,7 +200,8 @@ RAJA_DEVICE RAJA_INLINE int grid_reduce_last_block(T& val,
 
 namespace expt {
 
-template <typename ThreadIterationGetter, typename Combiner, typename T>
+template <typename ThreadIterationGetter, template <typename, typename, typename> class Combiner, typename T>
+//template <typename ThreadIterationGetter, typename Combiner, typename T>
 RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 {
   const int numThreads = ThreadIterationGetter::size();
@@ -216,7 +217,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
     // reduce each warp
     for (int i = 1; i < RAJA::policy::cuda::device_constants.WARP_SIZE; i *= 2) {
       T rhs = RAJA::cuda::impl::shfl_xor_sync(temp, i);
-      temp = Combiner{}(temp, rhs);
+      temp = Combiner<T,T,T>{}(temp, rhs);
     }
 
   } else {
@@ -227,7 +228,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
       T rhs = RAJA::cuda::impl::shfl_sync(temp, srcLane);
       // only add from threads that exist (don't double count own value)
       if (srcLane < numThreads) {
-        temp = Combiner{}(temp, rhs);
+        temp = Combiner<T,T,T>{}(temp, rhs);
       }
     }
   }
@@ -263,7 +264,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 
       for (int i = 1; i < RAJA::policy::cuda::device_constants.MAX_WARPS; i *= 2) {
         T rhs = RAJA::cuda::impl::shfl_xor_sync(temp, i);
-        temp = Combiner{}(temp, rhs);
+        temp = Combiner<T,T,T>{}(temp, rhs);
       }
     }
 
@@ -274,8 +275,11 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 }
 
 
-template <typename GlobalIterationGetter, typename OP, typename T>
-RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red)
+template <typename GlobalIterationGetter, template <typename, typename, typename> class OP, typename T>
+RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
+                                          T val,
+                                          RAJA::detail::SoAPtr<T,RAJA::cuda::device_mempool_type> device_mem,
+                                          unsigned int* device_count)
 {
   using BlockIterationGetter = typename get_index_block<GlobalIterationGetter>::type;
   using ThreadIterationGetter = typename get_index_thread<GlobalIterationGetter>::type;
@@ -287,7 +291,54 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red
   const int blockId = BlockIterationGetter::index();
   const int threadId = ThreadIterationGetter::index();
 
-  T temp = block_reduce<ThreadIterationGetter, OP>(red.val, OP::identity());
+  T temp = block_reduce<ThreadIterationGetter, OP>(val, OP<T,T,T>::identity());
+
+  // one thread per block writes to device_mem
+  bool lastBlock = false;
+  if (threadId == 0) {
+    device_mem.set(blockId, temp);
+    // ensure write visible to all threadblocks
+    __threadfence();
+    // increment counter, (wraps back to zero if old count == wrap_around)
+    unsigned int old_count = ::atomicInc(device_count, wrap_around);
+    lastBlock = (old_count == wrap_around);
+  }
+
+  // returns non-zero value if any thread passes in a non-zero value
+  lastBlock = __syncthreads_or(lastBlock);
+
+  // last block accumulates values from device_mem
+  if (lastBlock) {
+    temp = OP<T,T,T>::identity();
+    __threadfence();
+
+    for (int i = threadId; i < numBlocks; i += numThreads) {
+      temp = OP<T,T,T>{}(temp, device_mem.get(i));
+    }
+
+    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP<T,T,T>::identity());
+
+    // one thread returns value
+    if (threadId == 0) {
+      *device_target = temp;
+    }
+  }
+}
+
+template <typename GlobalIterationGetter, template <typename, typename, typename> class OP, typename T>
+RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T, T>& red)
+{
+  using BlockIterationGetter = typename get_index_block<GlobalIterationGetter>::type;
+  using ThreadIterationGetter = typename get_index_thread<GlobalIterationGetter>::type;
+
+  const int numBlocks = BlockIterationGetter::size();
+  const int numThreads = ThreadIterationGetter::size();
+  const unsigned int wrap_around = numBlocks - 1;
+
+  const int blockId = BlockIterationGetter::index();
+  const int threadId = ThreadIterationGetter::index();
+
+  T temp = block_reduce<ThreadIterationGetter, OP>(red.val, OP<T,T,T>::identity());
 
   // one thread per block writes to device_mem
   bool lastBlock = false;
@@ -305,14 +356,14 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red
 
   // last block accumulates values from device_mem
   if (lastBlock) {
-    temp = OP::identity();
+    temp = OP<T,T,T>::identity();
     __threadfence();
 
     for (int i = threadId; i < numBlocks; i += numThreads) {
-      temp = OP{}(temp, red.device_mem.get(i));
+      temp = OP<T,T,T>{}(temp, red.device_mem.get(i));
     }
 
-    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP::identity());
+    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP<T,T,T>::identity());
 
     // one thread returns value
     if (threadId == 0) {

From 36c3987ebf8dbd287e4bdf08ef470edae542296c Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 10:06:43 -0700
Subject: [PATCH 24/82] Update ValOp CUDA backend.

---
 include/RAJA/policy/cuda/params/reduce.hpp | 67 +++++++++++++++++++---
 1 file changed, 59 insertions(+), 8 deletions(-)

diff --git a/include/RAJA/policy/cuda/params/reduce.hpp b/include/RAJA/policy/cuda/params/reduce.hpp
index a2e734b1eb..c3258acb0f 100644
--- a/include/RAJA/policy/cuda/params/reduce.hpp
+++ b/include/RAJA/policy/cuda/params/reduce.hpp
@@ -8,14 +8,16 @@
 #include "RAJA/policy/cuda/reduce.hpp"
 #include "RAJA/pattern/params/reducer.hpp"
 
+#include "RAJA/policy/cuda/policy.hpp"
+
 namespace RAJA {
 namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  init(Reducer<OP, T>& red, RAJA::cuda::detail::cudaInfo& ci)
+  init(Reducer<OP, T, ValOp<T,OP>>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
     red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
@@ -23,22 +25,26 @@ namespace detail {
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  combine(Reducer<OP, T>& red)
+  combine(Reducer<OP, T, ValOp<T,OP>>& red)
   {
-    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter>(red);
+    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP, T>(red.devicetarget,
+                                                                            red.getVal(),
+                                                                            red.device_mem,
+                                                                            red.device_count);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  resolve(Reducer<OP, T>& red, RAJA::cuda::detail::cudaInfo& ci)
+  resolve(Reducer<OP, T, ValOp<T,OP>>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
     // complete reduction
     ci.res.wait();
-    *red.target = OP{}(*red.target, *red.devicetarget);
+
+    red.target->val = OP<T,T,T>{}(red.target->val, *red.devicetarget);
 
     // free memory
     RAJA::cuda::device_zeroed_mempool_type::getInstance().free(red.device_count);
@@ -48,6 +54,51 @@ namespace detail {
     red.devicetarget = nullptr;
   }
 
+//  // Init
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
+//  init(Reducer<OP, T, T>& red, RAJA::cuda::detail::cudaInfo& ci)
+//  {
+//    red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
+//    red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
+//    red.device_count = RAJA::cuda::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
+//  }
+//
+//  // Combine
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  RAJA_HOST_DEVICE
+//  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
+//  combine(Reducer<OP, T, T>& red)
+//  //combine(Reducer<OP, T>& red)
+//  {
+//    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter>(red);
+//    //RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter>(red.devicetarget,
+//    //                                                                        red.val,
+//    //                                                                        red.device_mem,
+//    //                                                                        red.device_count);
+//  }
+//
+//  // Resolve
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  //template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
+//  resolve(Reducer<OP, T, T>& red, RAJA::cuda::detail::cudaInfo& ci)
+//  //resolve(Reducer<OP, T>& red, RAJA::cuda::detail::cudaInfo& ci)
+//  {
+//    // complete reduction
+//    ci.res.wait();
+//    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
+//    printf( "RCC DANGER\n" );
+//
+//    // free memory
+//    RAJA::cuda::device_zeroed_mempool_type::getInstance().free(red.device_count);
+//    red.device_count = nullptr;
+//    red.device_mem.deallocate();
+//    RAJA::cuda::pinned_mempool_type::getInstance().free(red.devicetarget);
+//    red.devicetarget = nullptr;
+//  }
+
+
 } //  namespace detail
 } //  namespace expt
 } //  namespace RAJA

From c68119ade725f1fdaa131468e27c284ebfcb442c Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 10:09:28 -0700
Subject: [PATCH 25/82] Update HIP grid_reduce for ValOp.

---
 include/RAJA/policy/hip/reduce.hpp | 72 +++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 10 deletions(-)

diff --git a/include/RAJA/policy/hip/reduce.hpp b/include/RAJA/policy/hip/reduce.hpp
index e8e67029ef..843bdee09e 100644
--- a/include/RAJA/policy/hip/reduce.hpp
+++ b/include/RAJA/policy/hip/reduce.hpp
@@ -194,7 +194,8 @@ RAJA_DEVICE RAJA_INLINE int grid_reduce_last_block(T& val,
 
 namespace expt {
 
-template <typename ThreadIterationGetter, typename Combiner, typename T>
+template <typename ThreadIterationGetter, template <typename, typename, typename> class Combiner, typename T>
+//template <typename ThreadIterationGetter, typename Combiner, typename T>
 RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 {
   const int numThreads = ThreadIterationGetter::size();
@@ -210,7 +211,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
     // reduce each warp
     for (int i = 1; i < RAJA::policy::hip::device_constants.WARP_SIZE; i *= 2) {
       T rhs = RAJA::hip::impl::shfl_xor_sync(temp, i);
-      temp = Combiner{}(temp, rhs);
+      temp = Combiner<T,T,T>{}(temp, rhs);
     }
 
   } else {
@@ -221,7 +222,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
       T rhs = RAJA::hip::impl::shfl_sync(temp, srcLane);
       // only add from threads that exist (don't double count own value)
       if (srcLane < numThreads) {
-        temp = Combiner{}(temp, rhs);
+        temp = Combiner<T,T,T>{}(temp, rhs);
       }
     }
   }
@@ -257,7 +258,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 
       for (int i = 1; i < RAJA::policy::hip::device_constants.MAX_WARPS; i *= 2) {
         T rhs = RAJA::hip::impl::shfl_xor_sync(temp, i);
-        temp = Combiner{}(temp, rhs);
+        temp = Combiner<T,T,T>{}(temp, rhs);
       }
     }
 
@@ -268,8 +269,11 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 }
 
 
-template <typename GlobalIterationGetter, typename OP, typename T>
-RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red)
+template <typename GlobalIterationGetter, template <typename, typename, typename> class OP, typename T>
+RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
+                                          T val,
+                                          RAJA::detail::SoAPtr<T,RAJA::hip::device_mempool_type> device_mem,
+                                          unsigned int * device_count)
 {
   using BlockIterationGetter = typename get_index_block<GlobalIterationGetter>::type;
   using ThreadIterationGetter = typename get_index_thread<GlobalIterationGetter>::type;
@@ -281,7 +285,55 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red
   const int blockId = BlockIterationGetter::index();
   const int threadId = ThreadIterationGetter::index();
 
-  T temp = block_reduce<ThreadIterationGetter, OP>(red.val, OP::identity());
+  T temp = block_reduce<ThreadIterationGetter, OP>(val, OP<T,T,T>::identity());
+
+  // one thread per block writes to device_mem
+  bool lastBlock = false;
+  if (threadId == 0) {
+    device_mem.set(blockId, temp);
+    // ensure write visible to all threadblocks
+    __threadfence();
+    // increment counter, (wraps back to zero if old count == wrap_around)
+    unsigned int old_count = ::atomicInc(device_count, wrap_around);
+    lastBlock = (old_count == wrap_around);
+  }
+
+  // returns non-zero value if any thread passes in a non-zero value
+  lastBlock = __syncthreads_or(lastBlock);
+
+  // last block accumulates values from device_mem
+  if (lastBlock) {
+    temp = OP<T,T,T>::identity();
+    __threadfence();
+
+    for (int i = threadId; i < numBlocks; i += numThreads) {
+      temp = OP<T,T,T>{}(temp, device_mem.get(i));
+    }
+
+    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP<T,T,T>::identity());
+
+    // one thread returns value
+    if (threadId == 0) {
+      *device_target = temp;
+    }
+  }
+}
+
+
+template <typename GlobalIterationGetter, template <typename, typename, typename> class OP, typename T>
+RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T, T>& red)
+{
+  using BlockIterationGetter = typename get_index_block<GlobalIterationGetter>::type;
+  using ThreadIterationGetter = typename get_index_thread<GlobalIterationGetter>::type;
+
+  const int numBlocks = BlockIterationGetter::size();
+  const int numThreads = ThreadIterationGetter::size();
+  const unsigned int wrap_around = numBlocks - 1;
+
+  const int blockId = BlockIterationGetter::index();
+  const int threadId = ThreadIterationGetter::index();
+
+  T temp = block_reduce<ThreadIterationGetter, OP>(red.val, OP<T,T,T>::identity());
 
   // one thread per block writes to device_mem
   bool lastBlock = false;
@@ -299,14 +351,14 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red
 
   // last block accumulates values from device_mem
   if (lastBlock) {
-    temp = OP::identity();
+    temp = OP<T,T,T>::identity();
     __threadfence();
 
     for (int i = threadId; i < numBlocks; i += numThreads) {
-      temp = OP{}(temp, red.device_mem.get(i));
+      temp = OP<T,T,T>{}(temp, red.device_mem.get(i));
     }
 
-    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP::identity());
+    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP<T,T,T>::identity());
 
     // one thread returns value
     if (threadId == 0) {

From 424aedd016800b3e5e13c561b060551ddd91c9f3 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 10:10:57 -0700
Subject: [PATCH 26/82] Update ValOp HIP backend.

---
 include/RAJA/policy/hip/params/reduce.hpp | 58 +++++++++++++++++++----
 1 file changed, 50 insertions(+), 8 deletions(-)

diff --git a/include/RAJA/policy/hip/params/reduce.hpp b/include/RAJA/policy/hip/params/reduce.hpp
index 584d049c5b..02905317c4 100644
--- a/include/RAJA/policy/hip/params/reduce.hpp
+++ b/include/RAJA/policy/hip/params/reduce.hpp
@@ -13,9 +13,9 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  init(Reducer<OP, T>& red, RAJA::hip::detail::hipInfo& hi)
+  init(Reducer<OP, T, ValOp<T,OP>>& red, RAJA::hip::detail::hipInfo& hi)
   {
     red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
@@ -23,22 +23,25 @@ namespace detail {
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  combine(Reducer<OP, T>& red)
+  combine(Reducer<OP, T, ValOp<T,OP>>& red)
   {
-    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter>(red);
+    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP,T>( red.devicetarget,
+                                                                            red.getVal(),
+                                                                            red.device_mem,
+                                                                            red.device_count);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  resolve(Reducer<OP, T>& red, RAJA::hip::detail::hipInfo& hi)
+  resolve(Reducer<OP, T, ValOp<T,OP>>& red, RAJA::hip::detail::hipInfo& hi)
   {
     // complete reduction
     hi.res.wait();
-    *red.target = OP{}(*red.target, *red.devicetarget);
+    red.target->val = OP<T,T,T>{}(red.target->val, *red.devicetarget);
 
     // free memory
     RAJA::hip::device_zeroed_mempool_type::getInstance().free(red.device_count);
@@ -48,6 +51,45 @@ namespace detail {
     red.devicetarget = nullptr;
   }
 
+//  // Init
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  //template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
+//  init(Reducer<OP, T, T>& red, RAJA::hip::detail::hipInfo& hi)
+//  {
+//    red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
+//    red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
+//    red.device_count = RAJA::hip::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
+//  }
+//
+//  // Combine
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  //template<typename EXEC_POL, typename OP, typename T>
+//  RAJA_HOST_DEVICE
+//  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
+//  combine(Reducer<OP, T, T>& red)
+//  {
+//    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter>(red);
+//  }
+//
+//  // Resolve
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  //template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
+//  resolve(Reducer<OP, T, T>& red, RAJA::hip::detail::hipInfo& hi)
+//  {
+//    // complete reduction
+//    hi.res.wait();
+//    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
+//
+//    // free memory
+//    RAJA::hip::device_zeroed_mempool_type::getInstance().free(red.device_count);
+//    red.device_count = nullptr;
+//    red.device_mem.deallocate();
+//    RAJA::hip::pinned_mempool_type::getInstance().free(red.devicetarget);
+//    red.devicetarget = nullptr;
+//  }
+
 } //  namespace detail
 } //  namespace expt
 } //  namespace RAJA

From 41ce7fa7d37cb2d2b73c37c58e794f0cfa445d94 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 10:12:03 -0700
Subject: [PATCH 27/82] Update internal device allocations for ValOp.

---
 include/RAJA/util/SoAPtr.hpp | 74 ++++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/include/RAJA/util/SoAPtr.hpp b/include/RAJA/util/SoAPtr.hpp
index 47802d8f0a..717d7418ca 100644
--- a/include/RAJA/util/SoAPtr.hpp
+++ b/include/RAJA/util/SoAPtr.hpp
@@ -26,6 +26,9 @@
 #include "RAJA/pattern/detail/reduce.hpp"
 #include "RAJA/util/types.hpp"
 
+// for RAJA::expt::ValLoc
+#include "RAJA/pattern/params/params_base.hpp"
+
 namespace RAJA
 {
 
@@ -165,6 +168,77 @@ class SoAPtr<RAJA::reduce::detail::ValueLoc<T, IndexType, doing_min>, mempool, a
   second_type* mem_idx = nullptr;
 };
 
+/*!
+ * @brief Specialization for RAJA::expt::ValLoc.
+ */
+template <typename T, typename IndexType, typename mempool, typename accessor>
+class SoAPtr<RAJA::expt::ValLoc<T, IndexType>, mempool, accessor>
+{
+  using first_type = T;
+  using second_type = IndexType;
+
+  template < typename, typename, typename >
+  friend class SoAPtr; // friend other instantiations of this class
+
+public:
+  using value_type = RAJA::expt::ValLoc<T, IndexType>;
+
+  template < typename rhs_accessor >
+  using rebind_accessor = SoAPtr<value_type, mempool, rhs_accessor>;
+
+  SoAPtr() = default;
+  SoAPtr(SoAPtr const&) = default;
+  SoAPtr(SoAPtr &&) = default;
+  SoAPtr& operator=(SoAPtr const&) = default;
+  SoAPtr& operator=(SoAPtr &&) = default;
+
+  explicit SoAPtr(size_t size)
+      : mem(mempool::getInstance().template malloc<first_type>(size)),
+        mem_idx(mempool::getInstance().template malloc<second_type>(size))
+  {
+  }
+
+  template < typename rhs_accessor,
+             std::enable_if_t<!std::is_same<accessor, rhs_accessor>::value>* = nullptr >
+  RAJA_HOST_DEVICE
+  explicit SoAPtr(SoAPtr<value_type, mempool, rhs_accessor> const& rhs)
+    : mem(rhs.mem)
+    , mem_idx(rhs.mem_idx)
+  { }
+
+  SoAPtr& allocate(size_t size)
+  {
+    mem = mempool::getInstance().template malloc<first_type>(size);
+    mem_idx = mempool::getInstance().template malloc<second_type>(size);
+    return *this;
+  }
+
+  SoAPtr& deallocate()
+  {
+    mempool::getInstance().free(mem);
+    mem = nullptr;
+    mempool::getInstance().free(mem_idx);
+    mem_idx = nullptr;
+    return *this;
+  }
+
+  RAJA_HOST_DEVICE bool allocated() const { return mem != nullptr; }
+
+  RAJA_HOST_DEVICE value_type get(size_t i) const
+  {
+    return value_type(accessor::get(mem, i), accessor::get(mem_idx, i));
+  }
+  RAJA_HOST_DEVICE void set(size_t i, value_type val)
+  {
+    accessor::set(mem, i, first_type(val));
+    accessor::set(mem_idx, i, val.getLoc());
+  }
+
+private:
+  first_type* mem = nullptr;
+  second_type* mem_idx = nullptr;
+};
+
 }  // namespace detail
 
 }  // namespace RAJA

From 28e2611112022e164100c59804a81f3088c09c3c Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 10:12:22 -0700
Subject: [PATCH 28/82] Update ValOp OpenMP backend.

---
 include/RAJA/policy/openmp/params/reduce.hpp | 45 ++++++++++++++++----
 1 file changed, 36 insertions(+), 9 deletions(-)

diff --git a/include/RAJA/policy/openmp/params/reduce.hpp b/include/RAJA/policy/openmp/params/reduce.hpp
index ffa270b0f3..52ffc01697 100644
--- a/include/RAJA/policy/openmp/params/reduce.hpp
+++ b/include/RAJA/policy/openmp/params/reduce.hpp
@@ -10,26 +10,53 @@ namespace detail {
 #if defined(RAJA_ENABLE_OPENMP)
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T>& red) {
-    red.val = OP::identity();
+  init(Reducer<OP, T, ValOp<T,OP>>& red) {
+    red.val.val = OP<T,T,T>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-    out.val = OP{}(out.val, in.val);
+  combine(Reducer<OP, T, ValOp<T,OP>>& out, const Reducer<OP, T, ValOp<T,OP>>& in) {
+    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T>& red) {
-    *red.target = OP{}(*red.target, red.val);
+  resolve(Reducer<OP, T, ValOp<T,OP>>& red) {
+    red.target->val = OP<T,T,T>{}(red.target->val, red.val.val);
   }
 
+//  // Init
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  //template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+//  init(Reducer<OP, T, T>& red) {
+//  //init(Reducer<OP, T>& red) {
+//    red.val = OP<T,T,T>::identity();
+//  }
+//
+//  // Combine
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  //template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+//  combine(Reducer<OP, T, T>& out, const Reducer<OP, T, T>& in) {
+//  //combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
+//    out.val = OP<T,T,T>{}(out.val, in.val);
+//  }
+//
+//  // Resolve
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  //template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+//  resolve(Reducer<OP, T, T>& red) {
+//  //resolve(Reducer<OP, T>& red) {
+//    *red.target = OP<T,T,T>{}(*red.target, red.val);
+//  }
+
 #endif
 
 } //  namespace detail

From d8e32bfdfbb3490626aade9824dbe2615971b1c9 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 10:12:37 -0700
Subject: [PATCH 29/82] Update ValOp Sequential backend.

---
 .../RAJA/policy/sequential/params/reduce.hpp  | 43 +++++++++++++++----
 1 file changed, 34 insertions(+), 9 deletions(-)

diff --git a/include/RAJA/policy/sequential/params/reduce.hpp b/include/RAJA/policy/sequential/params/reduce.hpp
index 60f83c4079..d0a64ba981 100644
--- a/include/RAJA/policy/sequential/params/reduce.hpp
+++ b/include/RAJA/policy/sequential/params/reduce.hpp
@@ -8,24 +8,49 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  init(Reducer<OP, T>& red) {
-    red.val = OP::identity();
+  init(Reducer<OP, T, ValOp<T,OP>>& red) {
+    red.val.val = OP<T,T,T>::identity();
   }
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-    out.val = OP{}(out.val, in.val);
+  combine(Reducer<OP, T, ValOp<T,OP>>& out, const Reducer<OP, T, ValOp<T,OP>>& in) {
+    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
   }
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  resolve(Reducer<OP, T>& red) {
-    *red.target = OP{}(*red.target, red.val);
+  resolve(Reducer<OP, T, ValOp<T,OP>>& red) {
+    red.target->val = OP<T,T,T>{}(red.target->val, red.val.val);
   }
 
+//  // Init
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  //template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
+//  init(Reducer<OP, T, T>& red) {
+//  //init(Reducer<OP, T>& red) {
+//    red.val = OP<T,T,T>::identity();
+//  }
+//  // Combine
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  //template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
+//  combine(Reducer<OP, T, T>& out, const Reducer<OP, T, T>& in) {
+//  //combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
+//    out.val = OP<T,T,T>{}(out.val, in.val);
+//  }
+//  // Resolve
+//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+//  //template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
+//  resolve(Reducer<OP, T, T>& red) {
+//  //resolve(Reducer<OP, T>& red) {
+//    *red.target = OP<T,T,T>{}(*red.target, red.val);
+//  }
+
 } //  namespace detail
 } //  namespace expt
 } //  namespace RAJA

From 00324e3857e96593717075ffdf80fbe1eb024b9c Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 10:12:56 -0700
Subject: [PATCH 30/82] Update new reduction example.

---
 examples/forall-param-reductions.cpp | 178 +++++++++++++++++----------
 1 file changed, 115 insertions(+), 63 deletions(-)

diff --git a/examples/forall-param-reductions.cpp b/examples/forall-param-reductions.cpp
index fb82582704..1d3cd4d1f0 100644
--- a/examples/forall-param-reductions.cpp
+++ b/examples/forall-param-reductions.cpp
@@ -66,6 +66,11 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   }
 
+//
+// Set a[0] to a different value. Total sum should be 2.
+//
+  a[0] = 3;
+
 //
 // Set min and max loc values
 //
@@ -99,7 +104,8 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 // Define ValLoc Type
 //
 
-  using VALLOC_INT = RAJA::expt::ValLoc<int>;
+/*
+  using VALLOC_INT = RAJA::expt::ValLoc<int, RAJA::Index_type>;
 //----------------------------------------------------------------------------//
 
   std::cout << "\n Running RAJA sequential reductions...\n";
@@ -144,6 +150,58 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   std::cout << "\tmax, loc = " << seq_maxloc.getVal() << " , "
                                << seq_maxloc.getLoc() << std::endl;
   // _reductions_raja_seq_end
+*/
+
+
+//
+// Define ValLoc Safe Type
+//
+
+  using REF_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
+  using REF_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
+  using REF_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
+  using REFLOC_INT_MIN = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::minimum>;
+  using REFLOC_INT_MAX = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::maximum>;
+//----------------------------------------------------------------------------//
+
+  std::cout << "\n Running RAJA sequential safe reductions...\n";
+
+  using EXEC_POL1S   = RAJA::seq_exec;
+
+  REF_INT_SUM sseq_sum(0);
+  REF_INT_MIN sseq_min(std::numeric_limits<int>::max());
+  REF_INT_MAX sseq_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN sseq_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX sseq_maxloc(std::numeric_limits<int>::min(), -1);
+
+  RAJA::forall<EXEC_POL1S>(host_res, arange,
+    RAJA::expt::Reduce<>(&sseq_sum),
+    RAJA::expt::Reduce<>(&sseq_min),
+    RAJA::expt::Reduce<>(&sseq_max),
+    RAJA::expt::Reduce<>(&sseq_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&sseq_maxloc),
+    RAJA::expt::KernelName("RAJA Reduce Seq Safe Kernel"),
+    [=](int i, REF_INT_SUM &_sseq_sum, REF_INT_MIN &_sseq_min, REF_INT_MAX &_sseq_max, REFLOC_INT_MIN &_sseq_minloc, REFLOC_INT_MAX &_sseq_maxloc) {
+      _sseq_sum += a[i];
+
+      _sseq_min.min(a[i]);
+      _sseq_max.max(a[i]);
+
+      _sseq_minloc.minloc(a[i], i);
+      _sseq_maxloc.maxloc(a[i], i);
+      // Note : RAJA::expt::ValLoc<T> objects provide min() and max() methods
+      //        that are equivalent to the assignments with RAJA_MIN and RAJA_MAX
+      //        above.
+    }
+  );
+
+  std::cout << "\tsum = " << sseq_sum.get() << std::endl;
+  std::cout << "\tmin = " << sseq_min.get() << std::endl;
+  std::cout << "\tmax = " << sseq_max.get() << std::endl;
+  std::cout << "\tmin, loc = " << sseq_minloc.getVal() << " , "
+                               << sseq_minloc.getLoc() << std::endl;
+  std::cout << "\tmax, loc = " << sseq_maxloc.getVal() << " , "
+                               << sseq_maxloc.getLoc() << std::endl;
 
 
 //----------------------------------------------------------------------------//
@@ -155,35 +213,33 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using EXEC_POL2   = RAJA::omp_parallel_for_exec;
   // _reductions_raja_omppolicy_end
 
-  int omp_sum = 0;
-  int omp_min = std::numeric_limits<int>::max();
-  int omp_max = std::numeric_limits<int>::min();
-  VALLOC_INT omp_minloc(std::numeric_limits<int>::max(), -1);
-  VALLOC_INT omp_maxloc(std::numeric_limits<int>::min(), -1);
+  REF_INT_SUM omp_sum(0);
+  REF_INT_MIN omp_min(std::numeric_limits<int>::max());
+  REF_INT_MAX omp_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN omp_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX omp_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::forall<EXEC_POL2>(host_res, arange,
-    RAJA::expt::Reduce<RAJA::operators::plus>(&omp_sum),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_min),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_max),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_maxloc),
+    RAJA::expt::Reduce<>(&omp_sum),
+    RAJA::expt::Reduce<>(&omp_min),
+    RAJA::expt::Reduce<>(&omp_max),
+    RAJA::expt::Reduce<>(&omp_minloc),
+    RAJA::expt::Reduce<>(&omp_maxloc),
     RAJA::expt::KernelName("RAJA Reduce OpenMP Kernel"),
-    [=](int i, int &_omp_sum, int &_omp_min, int &_omp_max, VALLOC_INT &_omp_minloc, VALLOC_INT &_omp_maxloc) {
+    [=](int i, REF_INT_SUM &_omp_sum, REF_INT_MIN &_omp_min, REF_INT_MAX &_omp_max, REFLOC_INT_MIN &_omp_minloc, REFLOC_INT_MAX &_omp_maxloc) {
       _omp_sum += a[i];
 
-      _omp_min = RAJA_MIN(a[i], _omp_min);
-      _omp_max = RAJA_MAX(a[i], _omp_max);
+      _omp_min.min(a[i]);
+      _omp_max.max(a[i]);
 
-      _omp_minloc = RAJA_MIN(VALLOC_INT(a[i], i), _omp_minloc);
-      _omp_maxloc = RAJA_MAX(VALLOC_INT(a[i], i), _omp_maxloc);
-      //_omp_minloc.min(a[i], i);
-      //_omp_maxloc.max(a[i], i);
+      _omp_minloc.minloc(a[i], i);
+      _omp_maxloc.maxloc(a[i], i);
     }
   );
 
-  std::cout << "\tsum = " << omp_sum << std::endl;
-  std::cout << "\tmin = " << omp_min << std::endl;
-  std::cout << "\tmax = " << omp_max << std::endl;
+  std::cout << "\tsum = " << omp_sum.get() << std::endl;
+  std::cout << "\tmin = " << omp_min.get() << std::endl;
+  std::cout << "\tmax = " << omp_max.get() << std::endl;
   std::cout << "\tmin, loc = " << omp_minloc.getVal() << " , "
                                << omp_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << omp_maxloc.getVal() << " , "
@@ -253,35 +309,33 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using EXEC_POL3   = RAJA::cuda_exec<CUDA_BLOCK_SIZE>;
   // _reductions_raja_cudapolicy_end
 
-  int cuda_sum = 0;
-  int cuda_min = std::numeric_limits<int>::max();
-  int cuda_max = std::numeric_limits<int>::min();
-  VALLOC_INT cuda_minloc(std::numeric_limits<int>::max(), -1);
-  VALLOC_INT cuda_maxloc(std::numeric_limits<int>::min(), -1);
+  REF_INT_SUM cuda_sum(0);
+  REF_INT_MIN cuda_min(std::numeric_limits<int>::max());
+  REF_INT_MAX cuda_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN cuda_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX cuda_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::forall<EXEC_POL3>(cuda_res, arange,
-    RAJA::expt::Reduce<RAJA::operators::plus>(&cuda_sum),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_min),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_max),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_maxloc),
+    RAJA::expt::Reduce<>(&cuda_sum),
+    RAJA::expt::Reduce<>(&cuda_min),
+    RAJA::expt::Reduce<>(&cuda_max),
+    RAJA::expt::Reduce<>(&cuda_minloc),
+    RAJA::expt::Reduce<>(&cuda_maxloc),
     RAJA::expt::KernelName("RAJA Reduce CUDA Kernel"),
-    [=] RAJA_DEVICE (int i, int &_cuda_sum, int &_cuda_min, int &_cuda_max, VALLOC_INT &_cuda_minloc, VALLOC_INT &_cuda_maxloc) {
+    [=] RAJA_DEVICE (int i, REF_INT_SUM &_cuda_sum, REF_INT_MIN &_cuda_min, REF_INT_MAX &_cuda_max, REFLOC_INT_MIN &_cuda_minloc, REFLOC_INT_MAX &_cuda_maxloc) {
       _cuda_sum += d_a[i];
 
-      _cuda_min = RAJA_MIN(d_a[i], _cuda_min);
-      _cuda_max = RAJA_MAX(d_a[i], _cuda_max);
+      _cuda_min.min(d_a[i]);
+      _cuda_max.max(d_a[i]);
 
-      _cuda_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _cuda_minloc);
-      _cuda_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _cuda_maxloc);
-      //_cuda_minloc.min(a[i], i);
-      //_cuda_maxloc.max(a[i], i);
+      _cuda_minloc.minloc(a[i], i);
+      _cuda_maxloc.maxloc(a[i], i);
     }
   );
 
-  std::cout << "\tsum = " << cuda_sum << std::endl;
-  std::cout << "\tmin = " << cuda_min << std::endl;
-  std::cout << "\tmax = " << cuda_max << std::endl;
+  std::cout << "\tsum = " << cuda_sum.get() << std::endl;
+  std::cout << "\tmin = " << cuda_min.get() << std::endl;
+  std::cout << "\tmax = " << cuda_max.get() << std::endl;
   std::cout << "\tmin, loc = " << cuda_minloc.getVal() << " , "
                                << cuda_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << cuda_maxloc.getVal() << " , "
@@ -303,35 +357,33 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using EXEC_POL3   = RAJA::hip_exec<HIP_BLOCK_SIZE>;
   // _reductions_raja_hippolicy_end
 
-  int hip_sum = 0;
-  int hip_min = std::numeric_limits<int>::max();
-  int hip_max = std::numeric_limits<int>::min();
-  VALLOC_INT hip_minloc(std::numeric_limits<int>::max(), -1);
-  VALLOC_INT hip_maxloc(std::numeric_limits<int>::min(), -1);
-
-  RAJA::forall<EXEC_POL3>(arange,
-    RAJA::expt::Reduce<RAJA::operators::plus>(&hip_sum),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_min),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_max),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_maxloc),
+  REF_INT_SUM hip_sum(0);
+  REF_INT_MIN hip_min(std::numeric_limits<int>::max());
+  REF_INT_MAX hip_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN hip_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX hip_maxloc(std::numeric_limits<int>::min(), -1);
+
+  RAJA::forall<EXEC_POL3>(hip_res, arange,
+    RAJA::expt::Reduce<>(&hip_sum),
+    RAJA::expt::Reduce<>(&hip_min),
+    RAJA::expt::Reduce<>(&hip_max),
+    RAJA::expt::Reduce<>(&hip_minloc),
+    RAJA::expt::Reduce<>(&hip_maxloc),
     RAJA::expt::KernelName("RAJA Reduce HIP Kernel"),
-    [=] RAJA_DEVICE (int i, int &_hip_sum, int &_hip_min, int &_hip_max, VALLOC_INT &_hip_minloc, VALLOC_INT &_hip_maxloc) {
+    [=] RAJA_DEVICE (int i, REF_INT_SUM &_hip_sum, REF_INT_MIN &_hip_min, REF_INT_MAX &_hip_max, REFLOC_INT_MIN &_hip_minloc, REFLOC_INT_MAX &_hip_maxloc) {
       _hip_sum += d_a[i];
 
-      _hip_min = RAJA_MIN(d_a[i], _hip_min);
-      _hip_max = RAJA_MAX(d_a[i], _hip_max);
+      _hip_min.min(d_a[i]);
+      _hip_max.max(d_a[i]);
 
-      _hip_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _hip_minloc);
-      _hip_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _hip_maxloc);
-      //_hip_minloc.min(d_a[i], i);
-      //_hip_maxloc.max(d_a[i], i);
+      _hip_minloc.minloc(d_a[i], i);
+      _hip_maxloc.maxloc(d_a[i], i);
     }
   );
 
-  std::cout << "\tsum = " << hip_sum << std::endl;
-  std::cout << "\tmin = " << hip_min << std::endl;
-  std::cout << "\tmax = " << hip_max << std::endl;
+  std::cout << "\tsum = " << hip_sum.get() << std::endl;
+  std::cout << "\tmin = " << hip_min.get() << std::endl;
+  std::cout << "\tmax = " << hip_max.get() << std::endl;
   std::cout << "\tmin, loc = " << hip_minloc.getVal() << " , "
                                << hip_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << hip_maxloc.getVal() << " , "

From bd5ec5f18e8cb19ab642ab5c80ff660eb58b765f Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 15:18:43 -0700
Subject: [PATCH 31/82] Update SYCL backend for ValOp.

---
 include/RAJA/policy/sycl/params/reduce.hpp | 43 ++++++++++++++++------
 1 file changed, 31 insertions(+), 12 deletions(-)

diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index a1afbe5835..eaf4b770b8 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -10,27 +10,46 @@ namespace detail {
 #if defined(RAJA_ENABLE_SYCL)
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  init(Reducer<OP, T>& red) {
-    red.val = OP::identity();
+  init(Reducer<OP, T, ValOp<T,OP>>& red) {
+    red.val.val = OP<T,T,T>::identity();
   }
-
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  SYCL_EXTERNAL
-  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-    out.val = OP{}(out.val, in.val);
+  combine(Reducer<OP, T, ValOp<T,OP>>& out, const Reducer<OP, T, ValOp<T,OP>>& in) {
+    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
   }
-
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  resolve(Reducer<OP, T>& red) {
-    *red.target = OP{}(*red.target, red.val);
+  resolve(Reducer<OP, T, ValOp<T,OP>>& red) {
+    red.target->val = OP<T,T,T>{}(red.target->val, red.val.val);
   }
 
+//  // Init
+//  template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
+//  init(Reducer<OP, T>& red) {
+//    red.val = OP::identity();
+//  }
+//
+//  // Combine
+//  template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
+//  SYCL_EXTERNAL
+//  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
+//    out.val = OP{}(out.val, in.val);
+//  }
+//
+//  // Resolve
+//  template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
+//  resolve(Reducer<OP, T>& red) {
+//    *red.target = OP{}(*red.target, red.val);
+//  }
+
 #endif
 
 } //  namespace detail

From 048cb15467d8af4c4a299021b78e4189695dfb7c Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 15:19:07 -0700
Subject: [PATCH 32/82] Update example for SYCL ValOp.

---
 examples/forall-param-reductions.cpp | 38 +++++++++++++---------------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/examples/forall-param-reductions.cpp b/examples/forall-param-reductions.cpp
index 1d3cd4d1f0..5855b72056 100644
--- a/examples/forall-param-reductions.cpp
+++ b/examples/forall-param-reductions.cpp
@@ -406,35 +406,33 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using EXEC_POL3   = RAJA::sycl_exec<SYCL_BLOCK_SIZE>;
   // _reductions_raja_syclpolicy_end
 
-  int sycl_sum = 0;
-  int sycl_min = std::numeric_limits<int>::max();
-  int sycl_max = std::numeric_limits<int>::min();
-  VALLOC_INT sycl_minloc(std::numeric_limits<int>::max(), -1);
-  VALLOC_INT sycl_maxloc(std::numeric_limits<int>::min(), -1);
+  REF_INT_SUM sycl_sum(0);
+  REF_INT_MIN sycl_min(std::numeric_limits<int>::max());
+  REF_INT_MAX sycl_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN sycl_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX sycl_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::forall<EXEC_POL3>(sycl_res, arange,
-    RAJA::expt::Reduce<RAJA::operators::plus>(&sycl_sum),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_min),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_max),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_maxloc),
+    RAJA::expt::Reduce<>(&sycl_sum),
+    RAJA::expt::Reduce<>(&sycl_min),
+    RAJA::expt::Reduce<>(&sycl_max),
+    RAJA::expt::Reduce<>(&sycl_minloc),
+    RAJA::expt::Reduce<>(&sycl_maxloc),
     RAJA::expt::KernelName("RAJA Reduce SYCL Kernel"),
-    [=] RAJA_DEVICE (int i, int &_sycl_sum, int &_sycl_min, int &_sycl_max, VALLOC_INT &_sycl_minloc, VALLOC_INT &_sycl_maxloc) {
+    [=] RAJA_DEVICE (int i, REF_INT_SUM &_sycl_sum, REF_INT_MIN &_sycl_min, REF_INT_MAX &_sycl_max, REFLOC_INT_MIN &_sycl_minloc, REFLOC_INT_MAX &_sycl_maxloc) {
       _sycl_sum += d_a[i];
 
-      _sycl_min = RAJA_MIN(d_a[i], _sycl_min);
-      _sycl_max = RAJA_MAX(d_a[i], _sycl_max);
+      _sycl_min.min(d_a[i]);
+      _sycl_max.max(d_a[i]);
 
-      _sycl_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _sycl_minloc);
-      _sycl_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _sycl_maxloc);
-      //_sycl_minloc.min(d_a[i], i);
-      //_sycl_maxloc.max(d_a[i], i);
+      _sycl_minloc.minloc(d_a[i], i);
+      _sycl_maxloc.maxloc(d_a[i], i);
     }
   );
 
-  std::cout << "\tsum = " << sycl_sum << std::endl;
-  std::cout << "\tmin = " << sycl_min << std::endl;
-  std::cout << "\tmax = " << sycl_max << std::endl;
+  std::cout << "\tsum = " << sycl_sum.get() << std::endl;
+  std::cout << "\tmin = " << sycl_min.get() << std::endl;
+  std::cout << "\tmax = " << sycl_max.get() << std::endl;
   std::cout << "\tmin, loc = " << sycl_minloc.getVal() << " , "
                                << sycl_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << sycl_maxloc.getVal() << " , "

From 79fcd53e6af8ee42c409d24f81f810424dca1d0e Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 15:19:29 -0700
Subject: [PATCH 33/82] Minor corrections for SYCL build script.

---
 scripts/lc-builds/corona_sycl.sh | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/scripts/lc-builds/corona_sycl.sh b/scripts/lc-builds/corona_sycl.sh
index c343c4a3e8..815928e434 100755
--- a/scripts/lc-builds/corona_sycl.sh
+++ b/scripts/lc-builds/corona_sycl.sh
@@ -38,7 +38,7 @@ DATE=$(printf '%(%Y-%m-%d)T\n' -1)
 export PATH=${SYCL_PATH}/bin:$PATH
 export LD_LIBRARY_PATH=${SYCL_PATH}/lib:${SYCL_PATH}/lib64:$LD_LIBRARY_PATH
 
-module load cmake/3.24.2
+module load cmake/3.23.1
 
 cmake \
   -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \
@@ -69,9 +69,6 @@ echo "   1) Load the ROCm module version matching the version in the compiler pa
 echo "      you passed to this script."
 echo
 echo "   2) Prefix the LD_LIBRARY_PATH environment variable with "
-echo "        SYCL_PATH/lib:SYCL_PATH/lib64"
-echo
-echo "      where SYCL_PATH is set to the compiler installation path you passed"
-echo "      to this script (using the proper command for your shell)."
+echo "        ${SYCL_PATH}/lib:${SYCL_PATH}/lib64"
 echo
 echo "***********************************************************************"

From aec4372def71a5b1c83e681af7c85586619cc70a Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 15:34:13 -0700
Subject: [PATCH 34/82] Update OpenMP Target backend for ValOp.

---
 .../policy/openmp_target/params/reduce.hpp    | 39 ++++++++++++++-----
 1 file changed, 30 insertions(+), 9 deletions(-)

diff --git a/include/RAJA/policy/openmp_target/params/reduce.hpp b/include/RAJA/policy/openmp_target/params/reduce.hpp
index df5c6af235..784e1dc6fd 100644
--- a/include/RAJA/policy/openmp_target/params/reduce.hpp
+++ b/include/RAJA/policy/openmp_target/params/reduce.hpp
@@ -10,26 +10,47 @@ namespace detail {
 #if defined(RAJA_ENABLE_TARGET_OPENMP)
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T>& red) {
-    red.val = OP::identity();
+  init(Reducer<OP, T, ValOp<T,OP>>& red) {
+    red.val.val = OP<T,T,T>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-    out.val = OP{}(out.val, in.val);
+  combine(Reducer<OP, T, ValOp<T,OP>>& out, const Reducer<OP, T, ValOp<T,OP>>& in) {
+    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T>& red) {
-    *red.target = OP{}(*red.target, red.val);
+  resolve(Reducer<OP, T, ValOp<T,OP>>& red) {
+    red.target->val = OP<T,T,T>{}(red.target->val, red.val.val);
   }
 
+//  // Init
+//  template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
+//  init(Reducer<OP, T>& red) {
+//    red.val = OP::identity();
+//  }
+//
+//  // Combine
+//  template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
+//  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
+//    out.val = OP{}(out.val, in.val);
+//  }
+//
+//  // Resolve
+//  template<typename EXEC_POL, typename OP, typename T>
+//  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
+//  resolve(Reducer<OP, T>& red) {
+//    *red.target = OP{}(*red.target, red.val);
+//  }
+
 #endif
 
 } //  namespace detail

From 2a664237ce44e8b9d7fd5045660ea4982192fa4a Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 15:34:35 -0700
Subject: [PATCH 35/82] Update example for OpenMP Target.

---
 examples/forall-param-reductions.cpp | 38 +++++++++++++---------------
 1 file changed, 18 insertions(+), 20 deletions(-)

diff --git a/examples/forall-param-reductions.cpp b/examples/forall-param-reductions.cpp
index 5855b72056..9c2d4356ad 100644
--- a/examples/forall-param-reductions.cpp
+++ b/examples/forall-param-reductions.cpp
@@ -258,35 +258,33 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using EXEC_POL3   = RAJA::omp_target_parallel_for_exec_nt;
   // _reductions_raja_omppolicy_end
 
-  int omp_t_sum = 0;
-  int omp_t_min = std::numeric_limits<int>::max();
-  int omp_t_max = std::numeric_limits<int>::min();
-  VALLOC_INT omp_t_minloc(std::numeric_limits<int>::max(), -1);
-  VALLOC_INT omp_t_maxloc(std::numeric_limits<int>::min(), -1);
+  REF_INT_SUM omp_t_sum(0);
+  REF_INT_MIN omp_t_min(std::numeric_limits<int>::max());
+  REF_INT_MAX omp_t_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN omp_t_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX omp_t_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::forall<EXEC_POL3>(omp_res, arange,
-    RAJA::expt::Reduce<RAJA::operators::plus>(&omp_t_sum),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_t_min),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_t_max),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_t_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_t_maxloc),
+    RAJA::expt::Reduce<>(&omp_t_sum),
+    RAJA::expt::Reduce<>(&omp_t_min),
+    RAJA::expt::Reduce<>(&omp_t_max),
+    RAJA::expt::Reduce<>(&omp_t_minloc),
+    RAJA::expt::Reduce<>(&omp_t_maxloc),
     RAJA::expt::KernelName("RAJA Reduce Target OpenMP Kernel"),
-    [=](int i, int &_omp_t_sum, int &_omp_t_min, int &_omp_t_max, VALLOC_INT &_omp_t_minloc, VALLOC_INT &_omp_t_maxloc) {
+    [=](int i, REF_INT_SUM &_omp_t_sum, REF_INT_MIN &_omp_t_min, REF_INT_MAX &_omp_t_max, REFLOC_INT_MIN &_omp_t_minloc, REFLOC_INT_MAX &_omp_t_maxloc) {
       _omp_t_sum += a[i];
 
-      _omp_t_min = RAJA_MIN(a[i], _omp_t_min);
-      _omp_t_max = RAJA_MAX(a[i], _omp_t_max);
+      _omp_t_min.min(a[i]);
+      _omp_t_max.max(a[i]);
 
-      _omp_t_minloc = RAJA_MIN(VALLOC_INT(a[i], i), _omp_t_minloc);
-      _omp_t_maxloc = RAJA_MAX(VALLOC_INT(a[i], i), _omp_t_maxloc);
-      //_omp_t_minloc.min(a[i], i);
-      //_omp_t_maxloc.max(a[i], i);
+      _omp_t_minloc.minloc(a[i], i);
+      _omp_t_maxloc.maxloc(a[i], i);
     }
   );
 
-  std::cout << "\tsum = " << omp_t_sum << std::endl;
-  std::cout << "\tmin = " << omp_t_min << std::endl;
-  std::cout << "\tmax = " << omp_t_max << std::endl;
+  std::cout << "\tsum = " << omp_t_sum.get() << std::endl;
+  std::cout << "\tmin = " << omp_t_min.get() << std::endl;
+  std::cout << "\tmax = " << omp_t_max.get() << std::endl;
   std::cout << "\tmin, loc = " << omp_t_minloc.getVal() << " , "
                                << omp_t_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << omp_t_maxloc.getVal() << " , "

From 12d59325472d27ed27f49b5aefced6d44218d772 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 16:29:39 -0700
Subject: [PATCH 36/82] Add a set function to ValOp.

---
 include/RAJA/pattern/params/params_base.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index b01de9c7e7..6fff9fc25c 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -65,6 +65,7 @@ namespace expt
     RAJA_HOST_DEVICE constexpr bool operator>(const ValOp& rhs) const { val > rhs.val; return *this; }
 
     RAJA_HOST_DEVICE constexpr value_type get() const {return val;}
+    RAJA_HOST_DEVICE void set(value_type inval) {val = inval;}
 
   //private:
     value_type val = op_type::identity();

From b4797fc04dc20a4137ea9d08e4f375ad32d6f00a Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 6 Sep 2024 16:30:01 -0700
Subject: [PATCH 37/82] Update ReduceSum test.

---
 .../test-forall-basic-expt-ReduceSum.hpp      | 24 ++++++++++---------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
index a5a11acf09..2d9c6702e7 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
@@ -20,6 +20,8 @@ void ForallReduceSumBasicTestImpl(const SEG_TYPE& seg,
                                   const std::vector<IDX_TYPE>& seg_idx,
                                   camp::resources::Resource working_res)
 {
+  using REF_INT_SUM = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::plus>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -46,34 +48,34 @@ void ForallReduceSumBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  DATA_TYPE sum = 0;
-  DATA_TYPE sum2 = 2;
+  REF_INT_SUM sum(0);
+  REF_INT_SUM sum2(2);
 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
-    RAJA::expt::Reduce<RAJA::operators::plus>(&sum2),
+    RAJA::expt::Reduce<>(&sum),
+    RAJA::expt::Reduce<>(&sum2),
     RAJA::expt::KernelName("RAJA Reduce Sum"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &s1, DATA_TYPE &s2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_INT_SUM &s1, REF_INT_SUM &s2) {
       s1 += working_array[idx];
       s2 += working_array[idx];
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum), ref_sum);
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum2), ref_sum + 2);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum.get()), ref_sum);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum2.get()), ref_sum + 2);
 
-  sum = 0;
+  sum.set(0);
 
   const int nloops = 2;
 
   for (int j = 0; j < nloops; ++j) {
     RAJA::forall<EXEC_POLICY>(seg, 
-      RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
-      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &s) {
+      RAJA::expt::Reduce<>(&sum),
+      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_INT_SUM &s) {
         s += working_array[idx];
     });
   }
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum), nloops * ref_sum);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum.get()), nloops * ref_sum);
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,

From d27c5a1784d4d943dbe5068af87e17c78712195b Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Mon, 9 Sep 2024 12:27:44 -0700
Subject: [PATCH 38/82] Some setter and getter functions. May change later.

---
 include/RAJA/pattern/params/params_base.hpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index 6fff9fc25c..a891996a4d 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -102,6 +102,9 @@ namespace expt
     RAJA_HOST_DEVICE constexpr valloc_value_type getVal() const {return val.getVal();}
     RAJA_HOST_DEVICE constexpr valloc_index_type getLoc() const {return val.getLoc();}
 
+    RAJA_HOST_DEVICE void setVal(T inval) {val.val = inval;}
+    RAJA_HOST_DEVICE void setLoc(index_type inindex) {val.loc = inindex;}
+
   //private:
     value_type val = op_type::identity();
   };

From 0b74740c1539c17573237f2f339cba10c81ffc0a Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Mon, 9 Sep 2024 12:28:28 -0700
Subject: [PATCH 39/82] Update new reducer forall tests.

---
 .../test-forall-basic-expt-ReduceBitAnd.hpp   | 32 ++++++++-------
 .../test-forall-basic-expt-ReduceBitOr.hpp    | 32 ++++++++-------
 .../test-forall-basic-expt-ReduceMax.hpp      | 40 ++++++++++---------
 .../test-forall-basic-expt-ReduceMaxLoc.hpp   | 21 +++++-----
 .../test-forall-basic-expt-ReduceMin.hpp      | 40 ++++++++++---------
 .../test-forall-basic-expt-ReduceMinLoc.hpp   | 21 +++++-----
 .../test-forall-basic-expt-ReduceSum.hpp      | 10 ++---
 7 files changed, 105 insertions(+), 91 deletions(-)

diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp
index b1524827e0..d675d4bd32 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp
@@ -20,6 +20,8 @@ void ForallReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
                                      const std::vector<IDX_TYPE>& seg_idx,
                                      camp::resources::Resource working_res)
 {
+  using REF_BITAND = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::bit_and>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -41,10 +43,12 @@ void ForallReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
   }
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  RAJA::ReduceBitAnd<REDUCE_POLICY, DATA_TYPE> simpand(21);
+  REF_BITAND simpand(21);
 
-  RAJA::forall<EXEC_POLICY>(seg, [=] RAJA_HOST_DEVICE(IDX_TYPE idx) {
-    simpand &= working_array[idx];
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::Reduce<>(&simpand),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITAND & _simpand) {
+      _simpand &= working_array[idx];
   });
 
   ASSERT_EQ(static_cast<DATA_TYPE>(simpand.get()), 5);
@@ -66,33 +70,33 @@ void ForallReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
     ref_and &= test_array[ seg_idx[i] ];
   }
 
-  DATA_TYPE redand(0);
-  DATA_TYPE redand2(2);
+  REF_BITAND redand(0);
+  REF_BITAND redand2(2);
 
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
-    RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand2),
+    RAJA::expt::Reduce<>(&redand),
+    RAJA::expt::Reduce<>(&redand2),
     RAJA::expt::KernelName("RAJA Reduce BitAnd"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &r1, DATA_TYPE &r2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITAND &r1, REF_BITAND &r2) {
       r1 &= working_array[idx];
       r2 &= working_array[idx];
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand), ref_and);
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand2), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand.get()), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand2.get()), ref_and);
 
-  redand = 0;
+  redand.set(0);
 
   const int nloops = 3;
   for (int j = 0; j < nloops; ++j) {
     RAJA::forall<EXEC_POLICY>(seg,
-      RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
-      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &r1) {
+      RAJA::expt::Reduce<>(&redand),
+      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITAND &r1) {
         r1 &= working_array[idx];
     });
   }
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand.get()), ref_and);
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp
index 6e83c14e95..e498f75e0d 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp
@@ -20,6 +20,8 @@ void ForallReduceBitOrBasicTestImpl(const SEG_TYPE& seg,
                                      const std::vector<IDX_TYPE>& seg_idx,
                                      camp::resources::Resource working_res)
 {
+  using REF_BITOR = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::bit_or>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -41,10 +43,12 @@ void ForallReduceBitOrBasicTestImpl(const SEG_TYPE& seg,
   }
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  RAJA::ReduceBitOr<REDUCE_POLICY, DATA_TYPE> simpor(5);
+  REF_BITOR simpor(5);
 
-  RAJA::forall<EXEC_POLICY>(seg, [=] RAJA_HOST_DEVICE(IDX_TYPE idx) {
-    simpor |= working_array[idx];
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::Reduce<>(&simpor),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITOR & _simpor) {
+      _simpor |= working_array[idx];
   });
 
   ASSERT_EQ(static_cast<DATA_TYPE>(simpor.get()), 13);
@@ -66,33 +70,33 @@ void ForallReduceBitOrBasicTestImpl(const SEG_TYPE& seg,
     ref_or |= test_array[ seg_idx[i] ];
   }
 
-  DATA_TYPE redor(0);
-  DATA_TYPE redor2(2);
+  REF_BITOR redor(0);
+  REF_BITOR redor2(2);
 
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::bit_or>(&redor),
-    RAJA::expt::Reduce<RAJA::operators::bit_or>(&redor2),
+    RAJA::expt::Reduce<>(&redor),
+    RAJA::expt::Reduce<>(&redor2),
     RAJA::expt::KernelName("RAJA Reduce BitOr"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &r1, DATA_TYPE &r2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITOR &r1, REF_BITOR &r2) {
       r1 |= working_array[idx];
       r2 |= working_array[idx];
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redor), ref_or);
-  ASSERT_EQ(static_cast<DATA_TYPE>(redor2), ref_or);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redor.get()), ref_or);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redor2.get()), ref_or);
 
-  redor = 0;
+  redor.set(0);
 
   const int nloops = 3;
   for (int j = 0; j < nloops; ++j) {
     RAJA::forall<EXEC_POLICY>(seg,
-      RAJA::expt::Reduce<RAJA::operators::bit_or>(&redor),
-      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &r1) {
+      RAJA::expt::Reduce<>(&redor),
+      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITOR &r1) {
         r1 |= working_array[idx];
     });
   }
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redor), ref_or);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redor.get()), ref_or);
    
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp
index 75b9fce4e3..e8dfe2092b 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp
@@ -20,6 +20,8 @@ void ForallReduceMaxBasicTestImpl(const SEG_TYPE& seg,
                                   const std::vector<IDX_TYPE>& seg_idx,
                                   camp::resources::Resource working_res)
 {
+  using REF_MAX = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::maximum>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
  
@@ -48,39 +50,39 @@ void ForallReduceMaxBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  DATA_TYPE maxinit = big_max;
-  DATA_TYPE max(max_init);
+  REF_MAX maxinit(big_max);
+  REF_MAX max(max_init);
 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&maxinit),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
+    RAJA::expt::Reduce<>(&maxinit),
+    RAJA::expt::Reduce<>(&max),
     RAJA::expt::KernelName("RAJA Reduce Max"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &mi, DATA_TYPE &m) {
-      mi = RAJA_MAX(working_array[idx], mi);
-      m  = RAJA_MAX(working_array[idx], m);
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MAX &mi, REF_MAX &m) {
+      mi.max(working_array[idx]);
+      m.max(working_array[idx]);
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(maxinit), big_max);
-  ASSERT_EQ(static_cast<DATA_TYPE>(max), ref_max);
+  ASSERT_EQ(static_cast<DATA_TYPE>(maxinit.get()), big_max);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max.get()), ref_max);
 
-  max = max_init;
-  ASSERT_EQ(static_cast<DATA_TYPE>(max), max_init);
+  max.set(max_init);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max.get()), max_init);
 
   DATA_TYPE factor = 2;
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &m) {
-      m = RAJA_MAX(working_array[idx] * factor, m);
+    RAJA::expt::Reduce<>(&max),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MAX &m) {
+      m.max(working_array[idx] * factor);
   });
-  ASSERT_EQ(static_cast<DATA_TYPE>(max), ref_max * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max.get()), ref_max * factor);
    
   factor = 3;
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &m) {
-      m = RAJA_MAX(working_array[idx] * factor, m);
+    RAJA::expt::Reduce<>(&max),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MAX &m) {
+      m.max(working_array[idx] * factor);
   });
-  ASSERT_EQ(static_cast<DATA_TYPE>(max), ref_max * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max.get()), ref_max * factor);
    
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
index fbea0e034c..4da9647194 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
@@ -57,17 +57,17 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
 
-  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE>;
+  using VL_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::maximum>;
   VL_TYPE maxinit(big_max, maxloc_init);
   VL_TYPE max(max_init, maxloc_init);
 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&maxinit),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
+    RAJA::expt::Reduce<>(&maxinit),
+    RAJA::expt::Reduce<>(&max),
     RAJA::expt::KernelName("RAJA Reduce MaxLoc"),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &mi, VL_TYPE &m) {
-      mi.max( working_array[idx], idx );
-      m.max( working_array[idx], idx );
+      mi.maxloc( working_array[idx], idx );
+      m.maxloc( working_array[idx], idx );
   });
 
   ASSERT_EQ(static_cast<DATA_TYPE>(maxinit.getVal()), big_max);
@@ -75,24 +75,25 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
 
-  max = VL_TYPE(max_init, maxloc_init);
+  max.setVal(max_init);
+  max.setLoc(maxloc_init);
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), max_init);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), maxloc_init);
 
   DATA_TYPE factor = 2;
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
+    RAJA::expt::Reduce<>(&max),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
-      m.max( working_array[idx] * factor, idx);
+      m.maxloc( working_array[idx] * factor, idx);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
   
   factor = 3;
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
+    RAJA::expt::Reduce<>(&max),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
-      m.max( working_array[idx] * factor, idx);
+      m.maxloc( working_array[idx] * factor, idx);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp
index 78d9e0368c..29235a9bcb 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp
@@ -20,6 +20,8 @@ void ForallReduceMinBasicTestImpl(const SEG_TYPE& seg,
                                   const std::vector<IDX_TYPE>& seg_idx,
                                   camp::resources::Resource working_res)
 {
+  using REF_MIN = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::minimum>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -48,39 +50,39 @@ void ForallReduceMinBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  DATA_TYPE mininit = small_min;
-  DATA_TYPE min(min_init);
+  REF_MIN mininit(small_min);
+  REF_MIN min(min_init);
 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
+    RAJA::expt::Reduce<>(&mininit),
+    RAJA::expt::Reduce<>(&min),
     RAJA::expt::KernelName("RAJA Reduce Min"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &mi, DATA_TYPE &m) {
-      mi = RAJA_MIN(working_array[idx], mi);
-      m  = RAJA_MIN(working_array[idx], m);
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MIN &mi, REF_MIN &m) {
+      mi.min(working_array[idx]);
+      m.min(working_array[idx]);
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(mininit), small_min);
-  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min);
+  ASSERT_EQ(static_cast<DATA_TYPE>(mininit.get()), small_min);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min);
 
-  min = min_init;
-  ASSERT_EQ(static_cast<DATA_TYPE>(min), min_init);
+  min.set(min_init);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), min_init);
 
   DATA_TYPE factor = 3; 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &m) {
-      m = RAJA_MIN(working_array[idx] * factor, m);
+    RAJA::expt::Reduce<>(&min),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MIN &m) {
+      m.min(working_array[idx] * factor);
   });
-  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min * factor);
 
   factor = 2;
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &m) {
-      m = RAJA_MIN(working_array[idx] * factor, m);
+    RAJA::expt::Reduce<>(&min),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MIN &m) {
+      m.min(working_array[idx] * factor);
   });
-  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min * factor);
 
   deallocateForallTestData<DATA_TYPE>(working_res,
                                       working_array,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
index c0996f24c1..5ac1311c12 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
@@ -57,17 +57,17 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
 
-  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE>;
+  using VL_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::minimum>;
   VL_TYPE mininit(small_min, minloc_init);
   VL_TYPE min(min_init, minloc_init);
 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
+    RAJA::expt::Reduce<>(&mininit),
+    RAJA::expt::Reduce<>(&min),
     RAJA::expt::KernelName("RAJA Reduce MinLoc"),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &mi, VL_TYPE &m) {
-      mi.min( working_array[idx], idx );
-      m.min( working_array[idx], idx );
+      mi.minloc( working_array[idx], idx );
+      m.minloc( working_array[idx], idx );
   });
 
   ASSERT_EQ(static_cast<DATA_TYPE>(mininit.getVal()), small_min);
@@ -75,24 +75,25 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
 
-  min = VL_TYPE(min_init, minloc_init);
+  min.setVal(min_init);
+  min.setLoc(minloc_init);
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), min_init);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), minloc_init);
 
   DATA_TYPE factor = 2;
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
+    RAJA::expt::Reduce<>(&min),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
-      m.min( working_array[idx] * factor, idx);
+      m.minloc( working_array[idx] * factor, idx);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
 
   factor = 3;
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
+    RAJA::expt::Reduce<>(&min),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
-      m.min( working_array[idx] * factor, idx);
+      m.minloc( working_array[idx] * factor, idx);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
index 2d9c6702e7..ba672c4bd5 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
@@ -20,7 +20,7 @@ void ForallReduceSumBasicTestImpl(const SEG_TYPE& seg,
                                   const std::vector<IDX_TYPE>& seg_idx,
                                   camp::resources::Resource working_res)
 {
-  using REF_INT_SUM = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::plus>;
+  using REF_SUM = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::plus>;
 
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
@@ -48,14 +48,14 @@ void ForallReduceSumBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  REF_INT_SUM sum(0);
-  REF_INT_SUM sum2(2);
+  REF_SUM sum(0);
+  REF_SUM sum2(2);
 
   RAJA::forall<EXEC_POLICY>(seg, 
     RAJA::expt::Reduce<>(&sum),
     RAJA::expt::Reduce<>(&sum2),
     RAJA::expt::KernelName("RAJA Reduce Sum"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_INT_SUM &s1, REF_INT_SUM &s2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_SUM &s1, REF_SUM &s2) {
       s1 += working_array[idx];
       s2 += working_array[idx];
   });
@@ -70,7 +70,7 @@ void ForallReduceSumBasicTestImpl(const SEG_TYPE& seg,
   for (int j = 0; j < nloops; ++j) {
     RAJA::forall<EXEC_POLICY>(seg, 
       RAJA::expt::Reduce<>(&sum),
-      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_INT_SUM &s) {
+      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_SUM &s) {
         s += working_array[idx];
     });
   }

From 298c70f1f070310975d21764afb09ba981567d0f Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Mon, 9 Sep 2024 12:28:54 -0700
Subject: [PATCH 40/82] Update new reducer launch tests.

---
 ...t-launch-basic-param-expt-ReduceBitAnd.hpp | 32 ++++++++-------
 ...test-launch-basic-param-expt-ReduceMin.hpp | 40 ++++++++++---------
 ...test-launch-basic-param-expt-ReduceSum.hpp | 21 +++++-----
 3 files changed, 49 insertions(+), 44 deletions(-)

diff --git a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp
index 776b63f6b0..59c0a17ba3 100644
--- a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp
+++ b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp
@@ -22,6 +22,8 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
                                      const std::vector<IDX_TYPE>& seg_idx,
                                      camp::resources::Resource working_res)
 {
+  using REF_BITAND = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::bit_and>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -46,12 +48,12 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
   }
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  DATA_TYPE simpand(21);
+  REF_BITAND simpand(21);
 
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-     RAJA::expt::Reduce<RAJA::operators::bit_and>(&simpand),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_simpand) {
+     RAJA::expt::Reduce<>(&simpand),
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_BITAND &_simpand) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
 
@@ -60,7 +62,7 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
 
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(simpand), 5);
+  ASSERT_EQ(static_cast<DATA_TYPE>(simpand.get()), 5);
 
 
   //
@@ -79,38 +81,38 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
     ref_and &= test_array[ seg_idx[i] ];
   }
 
-  DATA_TYPE redand(0);
-  DATA_TYPE redand2(2);
+  REF_BITAND redand(0);
+  REF_BITAND redand2(2);
 
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-     RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
-     RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand2),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_redand, DATA_TYPE &_redand2) {
+     RAJA::expt::Reduce<>(&redand),
+     RAJA::expt::Reduce<>(&redand2),
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_BITAND &_redand, REF_BITAND &_redand2) {
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
         _redand  &= working_array[idx];
         _redand2 &= working_array[idx];
     });
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand), ref_and);
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand2), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand.get()), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand2.get()), ref_and);
 
-  redand = 0;
+  redand.set(0);
 
   const int nloops = 3;
   for (int j = 0; j < nloops; ++j) {
     RAJA::launch<LAUNCH_POLICY>
       (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-       RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
-       [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE _redand) {
+       RAJA::expt::Reduce<>(&redand),
+       [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_BITAND _redand) {
         RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
           _redand &= working_array[idx];
       });
     });
   }
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand.get()), ref_and);
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp
index 2936f2de09..9107aac69d 100644
--- a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp
+++ b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp
@@ -21,6 +21,8 @@ void LaunchParamExptReduceMinBasicTestImpl(const SEG_TYPE& seg,
                                            const std::vector<IDX_TYPE>& seg_idx,
                                            camp::resources::Resource working_res)
 {
+  using REF_MIN = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::minimum>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -52,60 +54,60 @@ void LaunchParamExptReduceMinBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  DATA_TYPE mininit(small_min);
-  DATA_TYPE min(min_init);
+  REF_MIN mininit(small_min);
+  REF_MIN min(min_init);
   
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
      "LaunchMinBasicTest",
-     RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
-     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_mininit, DATA_TYPE &_min) {
+     RAJA::expt::Reduce<>(&mininit),
+     RAJA::expt::Reduce<>(&min),
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_MIN &_mininit, REF_MIN &_min) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
 
-          _mininit = RAJA_MIN(working_array[idx], _mininit);
-          _min     = RAJA_MIN(working_array[idx], _min);
+          _mininit.min(working_array[idx]);
+          _min.min(working_array[idx]);
 
     });
 
   });
 
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(mininit), small_min);
-  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min);
+  ASSERT_EQ(static_cast<DATA_TYPE>(mininit.get()), small_min);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min);
 
-  min = min_init;
-  ASSERT_EQ(static_cast<DATA_TYPE>(min), min_init);
+  min.set(min_init);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), min_init);
 
   DATA_TYPE factor = 3;
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_min) {
+     RAJA::expt::Reduce<>(&min),
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_MIN &_min) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
 
-          _min = RAJA_MIN(working_array[idx] * factor, _min);
+          _min.min(working_array[idx] * factor);
     });
 
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min * factor);
 
 
   factor = 2;
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_min) {
+     RAJA::expt::Reduce<>(&min),
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_MIN &_min) {
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
 
-          _min = RAJA_MIN(working_array[idx] * factor, _min);
+          _min.min(working_array[idx] * factor);
       });
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min * factor);
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp
index bf4b29ec28..4339026a64 100644
--- a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp
+++ b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp
@@ -21,6 +21,7 @@ void LaunchParamExptReduceSumBasicTestImpl(const SEG_TYPE& seg,
                                            const std::vector<IDX_TYPE>& seg_idx,
                                            camp::resources::Resource working_res)
 {
+  using REF_SUM = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::plus>;
 
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
@@ -52,14 +53,14 @@ void LaunchParamExptReduceSumBasicTestImpl(const SEG_TYPE& seg,
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
 
-  DATA_TYPE sum(0), sum2(2);
+  REF_SUM sum(0), sum2(2);
 
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
      "LaunchSumBasicTest",
-     RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
-     RAJA::expt::Reduce<RAJA::operators::plus>(&sum2),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_sum, DATA_TYPE &_sum2) {
+     RAJA::expt::Reduce<>(&sum),
+     RAJA::expt::Reduce<>(&sum2),
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_SUM &_sum, REF_SUM &_sum2) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
           _sum  += working_array[idx];
@@ -68,18 +69,18 @@ void LaunchParamExptReduceSumBasicTestImpl(const SEG_TYPE& seg,
 
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum), ref_sum);
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum2), ref_sum + 2);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum.get()), ref_sum);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum2.get()), ref_sum + 2);
 
-  sum = 0;
+  sum.set(0);
 
   const int nloops = 2;
 
   for (int j = 0; j < nloops; ++j) {
     RAJA::launch<LAUNCH_POLICY>
       (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-       RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
-       [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_sum) {
+       RAJA::expt::Reduce<>(&sum),
+       [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_SUM &_sum) {
 
         RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
             _sum += working_array[idx];
@@ -87,7 +88,7 @@ void LaunchParamExptReduceSumBasicTestImpl(const SEG_TYPE& seg,
       });
   }
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum), nloops * ref_sum);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum.get()), nloops * ref_sum);
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,

From 38439bf8caab7e42a5b9123481dbed244f3b56bb Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Mon, 9 Sep 2024 12:29:20 -0700
Subject: [PATCH 41/82] Update launch example with ValOp.

---
 examples/launch-param-reductions.cpp | 231 ++++++++++++++-------------
 1 file changed, 121 insertions(+), 110 deletions(-)

diff --git a/examples/launch-param-reductions.cpp b/examples/launch-param-reductions.cpp
index b57bedfd6b..d49e859791 100644
--- a/examples/launch-param-reductions.cpp
+++ b/examples/launch-param-reductions.cpp
@@ -81,6 +81,11 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   }
 
+//
+// Set a[0] to a different value. Total sum should be 2.
+//
+  a[0] = 3;
+
 //
 // Set min and max loc values
 //
@@ -114,7 +119,12 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 // Define ValLoc Type
 //
 
-  using VALLOC_INT = RAJA::expt::ValLoc<int>;
+  //using VALLOC_INT = RAJA::expt::ValLoc<int>;
+  using REF_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
+  using REF_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
+  using REF_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
+  using REFLOC_INT_MIN = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::minimum>;
+  using REFLOC_INT_MAX = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::maximum>;
 //----------------------------------------------------------------------------//
 
   std::cout << "\n Running RAJA sequential reductions...\n";
@@ -123,35 +133,35 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using LAUNCH_POL1   = RAJA::LaunchPolicy<RAJA::seq_launch_t>;
   using LOOP_POL1     = RAJA::LoopPolicy<RAJA::seq_exec>;
 
-  int seq_sum = 0;
-  int seq_min = std::numeric_limits<int>::max();
-  int seq_max = std::numeric_limits<int>::min();
-  VALLOC_INT seq_minloc(std::numeric_limits<int>::max(), -1);
-  VALLOC_INT seq_maxloc(std::numeric_limits<int>::min(), -1);
+  REF_INT_SUM seq_sum(0);
+  REF_INT_MIN seq_min(std::numeric_limits<int>::max());
+  REF_INT_MAX seq_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN seq_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX seq_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::launch<LAUNCH_POL1>
     (host_res, RAJA::LaunchParams(), "SeqReductionKernel",
-    RAJA::expt::Reduce<RAJA::operators::plus>(&seq_sum),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_min),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_max),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_maxloc),
+    RAJA::expt::Reduce<>(&seq_sum),
+    RAJA::expt::Reduce<>(&seq_min),
+    RAJA::expt::Reduce<>(&seq_max),
+    RAJA::expt::Reduce<>(&seq_minloc),
+    RAJA::expt::Reduce<>(&seq_maxloc),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           int &_seq_sum, int &_seq_min,
-                           int &_seq_max, VALLOC_INT &_seq_minloc,
-                           VALLOC_INT &_seq_maxloc) {
+                           REF_INT_SUM &_seq_sum,
+                           REF_INT_MIN &_seq_min,
+                           REF_INT_MAX &_seq_max,
+                           REFLOC_INT_MIN &_seq_minloc,
+                           REFLOC_INT_MAX &_seq_maxloc) {
 
       RAJA::loop<LOOP_POL1>(ctx, arange, [&] (int i) {
 
           _seq_sum += a[i];
 
-          _seq_min = RAJA_MIN(a[i], _seq_min);
-          _seq_max = RAJA_MAX(a[i], _seq_max);
+          _seq_min.min(a[i]);
+          _seq_max.max(a[i]);
 
-          _seq_minloc = RAJA_MIN(VALLOC_INT(a[i], i), _seq_minloc);
-          _seq_maxloc = RAJA_MAX(VALLOC_INT(a[i], i), _seq_maxloc);
-          //_seq_minloc.min(a[i], i);
-          //_seq_maxloc.max(a[i], i);
+          _seq_minloc.minloc(a[i], i);
+          _seq_maxloc.maxloc(a[i], i);
           // Note : RAJA::expt::ValLoc<T> objects provide min() and max() methods
           //        that are equivalent to the assignments with RAJA_MIN and RAJA_MAX
           //        above.
@@ -161,9 +171,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << seq_sum << std::endl;
-  std::cout << "\tmin = " << seq_min << std::endl;
-  std::cout << "\tmax = " << seq_max << std::endl;
+  std::cout << "\tsum = " << seq_sum.get() << std::endl;
+  std::cout << "\tmin = " << seq_min.get() << std::endl;
+  std::cout << "\tmax = " << seq_max.get() << std::endl;
   std::cout << "\tmin, loc = " << seq_minloc.getVal() << " , "
                                << seq_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << seq_maxloc.getVal() << " , "
@@ -181,44 +191,44 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using LOOP_POL2     = RAJA::LoopPolicy<RAJA::omp_for_exec>;
   // _reductions_raja_omppolicy_end
 
-  int omp_sum = 0;
-  int omp_min = std::numeric_limits<int>::max();
-  int omp_max = std::numeric_limits<int>::min();
-  VALLOC_INT omp_minloc(std::numeric_limits<int>::max(), -1);
-  VALLOC_INT omp_maxloc(std::numeric_limits<int>::min(), -1);
+  REF_INT_SUM omp_sum(0);
+  REF_INT_MIN omp_min(std::numeric_limits<int>::max());
+  REF_INT_MAX omp_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN omp_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX omp_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::launch<LAUNCH_POL2>
     (host_res, RAJA::LaunchParams(), "OmpReductionKernel",
-    RAJA::expt::Reduce<RAJA::operators::plus>(&omp_sum),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_min),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_max),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_maxloc),
+    RAJA::expt::Reduce<>(&omp_sum),
+    RAJA::expt::Reduce<>(&omp_min),
+    RAJA::expt::Reduce<>(&omp_max),
+    RAJA::expt::Reduce<>(&omp_minloc),
+    RAJA::expt::Reduce<>(&omp_maxloc),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           int &_omp_sum, int &_omp_min,
-                           int &_omp_max, VALLOC_INT &_omp_minloc,
-                           VALLOC_INT &_omp_maxloc) {
+                           REF_INT_SUM &_omp_sum,
+                           REF_INT_MIN &_omp_min,
+                           REF_INT_MAX &_omp_max,
+                           REFLOC_INT_MIN &_omp_minloc,
+                           REFLOC_INT_MAX &_omp_maxloc) {
 
       RAJA::loop<LOOP_POL2>(ctx, arange, [&] (int i) {
 
           _omp_sum += a[i];
 
-          _omp_min = RAJA_MIN(a[i], _omp_min);
-          _omp_max = RAJA_MAX(a[i], _omp_max);
+          _omp_min.min(a[i]);
+          _omp_max.max(a[i]);
 
-          _omp_minloc = RAJA_MIN(VALLOC_INT(a[i], i), _omp_minloc);
-          _omp_maxloc = RAJA_MAX(VALLOC_INT(a[i], i), _omp_maxloc);
-          //_omp_minloc.min(a[i], i);
-          //_omp_maxloc.max(a[i], i);
+          _omp_minloc.minloc(a[i], i);
+          _omp_maxloc.maxloc(a[i], i);
         }
       );
 
     }
   );
 
-  std::cout << "\tsum = " << omp_sum << std::endl;
-  std::cout << "\tmin = " << omp_min << std::endl;
-  std::cout << "\tmax = " << omp_max << std::endl;
+  std::cout << "\tsum = " << omp_sum.get() << std::endl;
+  std::cout << "\tmin = " << omp_min.get() << std::endl;
+  std::cout << "\tmax = " << omp_max.get() << std::endl;
   std::cout << "\tmin, loc = " << omp_minloc.getVal() << " , "
                                << omp_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << omp_maxloc.getVal() << " , "
@@ -241,36 +251,37 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
   const int NUMBER_OF_TEAMS = (N-1)/CUDA_BLOCK_SIZE + 1;
 
-  int cuda_sum = 0;
-  int cuda_min = std::numeric_limits<int>::max();
-  int cuda_max = std::numeric_limits<int>::min();
-  VALLOC_INT cuda_minloc(std::numeric_limits<int>::max(), -1);
-  VALLOC_INT cuda_maxloc(std::numeric_limits<int>::min(), -1);
+  REF_INT_SUM cuda_sum(0);
+  REF_INT_MIN cuda_min(std::numeric_limits<int>::max());
+  REF_INT_MAX cuda_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN cuda_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX cuda_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::launch<LAUNCH_POL3>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(CUDA_BLOCK_SIZE)),
      "CUDAReductionKernel",
-    RAJA::expt::Reduce<RAJA::operators::plus>(&cuda_sum),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_min),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_max),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_maxloc),
+    RAJA::expt::Reduce<>(&cuda_sum),
+    RAJA::expt::Reduce<>(&cuda_min),
+    RAJA::expt::Reduce<>(&cuda_max),
+    RAJA::expt::Reduce<>(&cuda_minloc),
+    RAJA::expt::Reduce<>(&cuda_maxloc),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           int &_cuda_sum, int &_cuda_min, int &_cuda_max,
-                           VALLOC_INT &_cuda_minloc, VALLOC_INT &_cuda_maxloc) {
+                           REF_INT_SUM &_cuda_sum,
+                           REF_INT_MIN &_cuda_min,
+                           REF_INT_MAX &_cuda_max,
+                           REFLOC_INT_MIN &_cuda_minloc,
+                           REFLOC_INT_MAX &_cuda_maxloc) {
 
 
       RAJA::loop<LOOP_POL3>(ctx, arange, [&] (int i) {
 
           _cuda_sum += d_a[i];
 
-          _cuda_min = RAJA_MIN(d_a[i], _cuda_min);
-          _cuda_max = RAJA_MAX(d_a[i], _cuda_max);
+          _cuda_min.min(d_a[i]);
+          _cuda_max.max(d_a[i]);
 
-          _cuda_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _cuda_minloc);
-          _cuda_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _cuda_maxloc);
-          //_cuda_minloc.min(a[i], i);
-          //_cuda_maxloc.max(a[i], i);
+          _cuda_minloc.minloc(a[i], i);
+          _cuda_maxloc.maxloc(a[i], i);
 
         }
       );
@@ -279,9 +290,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << cuda_sum << std::endl;
-  std::cout << "\tmin = " << cuda_min << std::endl;
-  std::cout << "\tmax = " << cuda_max << std::endl;
+  std::cout << "\tsum = " << cuda_sum.get() << std::endl;
+  std::cout << "\tmin = " << cuda_min.get() << std::endl;
+  std::cout << "\tmax = " << cuda_max.get() << std::endl;
   std::cout << "\tmin, loc = " << cuda_minloc.getVal() << " , "
                                << cuda_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << cuda_maxloc.getVal() << " , "
@@ -305,36 +316,36 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
   const int NUMBER_OF_TEAMS = (N-1)/HIP_BLOCK_SIZE + 1;
 
-  int hip_sum = 0;
-  int hip_min = std::numeric_limits<int>::max();
-  int hip_max = std::numeric_limits<int>::min();
-  VALLOC_INT hip_minloc(std::numeric_limits<int>::max(), -1);
-  VALLOC_INT hip_maxloc(std::numeric_limits<int>::min(), -1);
+  REF_INT_SUM hip_sum(0);
+  REF_INT_MIN hip_min(std::numeric_limits<int>::max());
+  REF_INT_MAX hip_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN hip_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX hip_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::launch<LAUNCH_POL3>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(HIP_BLOCK_SIZE)),
      "HipReductionKernel",
-    RAJA::expt::Reduce<RAJA::operators::plus>(&hip_sum),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_min),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_max),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_maxloc),
+    RAJA::expt::Reduce<>(&hip_sum),
+    RAJA::expt::Reduce<>(&hip_min),
+    RAJA::expt::Reduce<>(&hip_max),
+    RAJA::expt::Reduce<>(&hip_minloc),
+    RAJA::expt::Reduce<>(&hip_maxloc),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           int &_hip_sum, int &_hip_min,
-                           int &_hip_max, VALLOC_INT &_hip_minloc,
-                           VALLOC_INT &_hip_maxloc) {
+                           REF_INT_SUM &_hip_sum,
+                           REF_INT_MIN &_hip_min,
+                           REF_INT_MAX &_hip_max,
+                           REFLOC_INT_MIN &_hip_minloc,
+                           REFLOC_INT_MAX &_hip_maxloc) {
 
       RAJA::loop<LOOP_POL3>(ctx, arange, [&] (int i) {
 
           _hip_sum += d_a[i];
 
-          _hip_min = RAJA_MIN(d_a[i], _hip_min);
-          _hip_max = RAJA_MAX(d_a[i], _hip_max);
+          _hip_min.min(d_a[i]);
+          _hip_max.max(d_a[i]);
 
-          _hip_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _hip_minloc);
-          _hip_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _hip_maxloc);
-          //_hip_minloc.min(d_a[i], i);
-          //_hip_maxloc.max(d_a[i], i);
+          _hip_minloc.minloc(d_a[i], i);
+          _hip_maxloc.maxloc(d_a[i], i);
 
         }
       );
@@ -342,9 +353,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << hip_sum << std::endl;
-  std::cout << "\tmin = " << hip_min << std::endl;
-  std::cout << "\tmax = " << hip_max << std::endl;
+  std::cout << "\tsum = " << hip_sum.get() << std::endl;
+  std::cout << "\tmin = " << hip_min.get() << std::endl;
+  std::cout << "\tmax = " << hip_max.get() << std::endl;
   std::cout << "\tmin, loc = " << hip_minloc.getVal() << " , "
                                << hip_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << hip_maxloc.getVal() << " , "
@@ -368,36 +379,36 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
   const int NUMBER_OF_TEAMS = (N-1)/SYCL_BLOCK_SIZE + 1;
 
-  int sycl_sum = 0;
-  int sycl_min = std::numeric_limits<int>::max();
-  int sycl_max = std::numeric_limits<int>::min();
-  VALLOC_INT sycl_minloc(std::numeric_limits<int>::max(), -1);
-  VALLOC_INT sycl_maxloc(std::numeric_limits<int>::min(), -1);
+  REF_INT_SUM sycl_sum(0);
+  REF_INT_MIN sycl_min(std::numeric_limits<int>::max());
+  REF_INT_MAX sycl_max(std::numeric_limits<int>::min());
+  REFLOC_INT_MIN sycl_minloc(std::numeric_limits<int>::max(), -1);
+  REFLOC_INT_MAX sycl_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::launch<LAUNCH_POL4>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(SYCL_BLOCK_SIZE)),
      "SyclReductionKernel",
-    RAJA::expt::Reduce<RAJA::operators::plus>(&sycl_sum),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_min),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_max),
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_maxloc),
+    RAJA::expt::Reduce<>(&sycl_sum),
+    RAJA::expt::Reduce<>(&sycl_min),
+    RAJA::expt::Reduce<>(&sycl_max),
+    RAJA::expt::Reduce<>(&sycl_minloc),
+    RAJA::expt::Reduce<>(&sycl_maxloc),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           int &_sycl_sum, int &_sycl_min,
-                           int &_sycl_max, VALLOC_INT &_sycl_minloc,
-                           VALLOC_INT &_sycl_maxloc) {
+                           REF_INT_SUM &_sycl_sum,
+                           REF_INT_MIN &_sycl_min,
+                           REF_INT_MAX &_sycl_max,
+                           REFLOC_INT_MIN &_sycl_minloc,
+                           REFLOC_INT_MAX &_sycl_maxloc) {
 
       RAJA::loop<LOOP_POL4>(ctx, arange, [&] (int i) {
 
           _sycl_sum += d_a[i];
 
-          _sycl_min = RAJA_MIN(d_a[i], _sycl_min);
-          _sycl_max = RAJA_MAX(d_a[i], _sycl_max);
+          _sycl_min.min(d_a[i]);
+          _sycl_max.max(d_a[i]);
 
-          _sycl_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _sycl_minloc);
-          _sycl_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _sycl_maxloc);
-          //_sycl_minloc.min(d_a[i], i);
-          //_sycl_maxloc.max(d_a[i], i);
+          _sycl_minloc.minloc(d_a[i], i);
+          _sycl_maxloc.maxloc(d_a[i], i);
 
         }
       );
@@ -405,9 +416,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << sycl_sum << std::endl;
-  std::cout << "\tmin = " << sycl_min << std::endl;
-  std::cout << "\tmax = " << sycl_max << std::endl;
+  std::cout << "\tsum = " << sycl_sum.get() << std::endl;
+  std::cout << "\tmin = " << sycl_min.get() << std::endl;
+  std::cout << "\tmax = " << sycl_max.get() << std::endl;
   std::cout << "\tmin, loc = " << sycl_minloc.getVal() << " , "
                                << sycl_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << sycl_maxloc.getVal() << " , "

From 9302951ea7abc2eef92dbc5bca2d548485159a82 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 13 Sep 2024 15:52:49 -0700
Subject: [PATCH 42/82] Simplify ValOp interface for user. ValOp only needed
 within lambdas.

---
 include/RAJA/pattern/params/params_base.hpp | 12 +++++----
 include/RAJA/pattern/params/reducer.hpp     | 29 ++++-----------------
 2 files changed, 12 insertions(+), 29 deletions(-)

diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index a891996a4d..313decc429 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -28,6 +28,8 @@ namespace expt
     RAJA_HOST_DEVICE constexpr value_type getVal() const {return val;}
     RAJA_HOST_DEVICE constexpr index_type getLoc() const {return loc;}
 
+    RAJA_HOST_DEVICE void set(T inval, IndexType inindex) {val = inval; loc = inindex;}
+
   //private:
     value_type val;
     index_type loc = -1;
@@ -98,12 +100,12 @@ namespace expt
     RAJA_HOST_DEVICE constexpr bool operator<(const ValOp& rhs) const { return val < rhs.val; }
     RAJA_HOST_DEVICE constexpr bool operator>(const ValOp& rhs) const { return val > rhs.val; }
 
-    RAJA_HOST_DEVICE constexpr value_type get() const {return val;}
-    RAJA_HOST_DEVICE constexpr valloc_value_type getVal() const {return val.getVal();}
-    RAJA_HOST_DEVICE constexpr valloc_index_type getLoc() const {return val.getLoc();}
+    //RAJA_HOST_DEVICE constexpr value_type get() const {return val;}
+    //RAJA_HOST_DEVICE constexpr valloc_value_type getVal() const {return val.getVal();}
+    //RAJA_HOST_DEVICE constexpr valloc_index_type getLoc() const {return val.getLoc();}
 
-    RAJA_HOST_DEVICE void setVal(T inval) {val.val = inval;}
-    RAJA_HOST_DEVICE void setLoc(index_type inindex) {val.loc = inindex;}
+    //RAJA_HOST_DEVICE void setVal(T inval) {val.val = inval;}
+    //RAJA_HOST_DEVICE void setLoc(index_type inindex) {val.loc = inindex;}
 
   //private:
     value_type val = op_type::identity();
diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index de1f58907a..5ea9a2bfa3 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -61,16 +61,11 @@ namespace detail
     using value_type = T;
 
     RAJA_HOST_DEVICE Reducer() {}
-    RAJA_HOST_DEVICE Reducer(VType *target_in) : target(target_in), val(VType{}){}
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : target(target_in), val(VType{}){}
 
-    VType *target = nullptr;
+    value_type *target = nullptr;
     VType val = VType{};
 
-    //template <typename U = VType, std::enable_if_t<std::is_same<U,value_type>::value>* = nullptr>
-    //RAJA_HOST_DEVICE
-    //value_type &
-    //getVal() { return val; }
-
     template <typename U = VType, std::enable_if_t<std::is_same<U,ValOp<T,Op>>::value>* = nullptr>
     RAJA_HOST_DEVICE
     value_type &
@@ -97,26 +92,12 @@ namespace detail
 
 } // namespace detail
 
-template <template <typename, typename, typename> class Op, typename T>
-auto constexpr Reduce(ValOp<T,Op> *target)
+template <template <typename, typename, typename> class Op, typename T, typename VType = ValOp<T, Op>>
+auto constexpr Reduce(T *target)
 {
-  return detail::Reducer<Op, T, ValOp<T,Op>>(target);
+  return detail::Reducer<Op, T, VType>(target);
 }
 
-//template <template <typename, typename, typename> class Op, typename T, typename IndexType,
-//           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value>* = nullptr >
-//auto constexpr Reduce(ValLoc<T, IndexType> *target)
-//{
-//  return detail::Reducer<Op, T, ValLoc<T, IndexType>>(target);
-//}
-
-//template <template <typename, typename, typename> class Op, typename T,
-//           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value>* = nullptr >
-//auto constexpr Reduce(T *target)
-//{
-//  return detail::Reducer<Op, T, T>(target);
-//}
-
 } // namespace expt
 
 

From 4a69f466b3de2f16f4d429d3226a1a33fc05e9da Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 13 Sep 2024 15:53:21 -0700
Subject: [PATCH 43/82] Update backends with simplified ValOp.

---
 include/RAJA/policy/cuda/params/reduce.hpp    | 14 +--
 include/RAJA/policy/hip/params/reduce.hpp     | 14 +--
 include/RAJA/policy/openmp/params/reduce.hpp  | 96 ++++++++++++-------
 .../policy/openmp_target/params/reduce.hpp    | 35 ++-----
 .../RAJA/policy/sequential/params/reduce.hpp  | 41 ++------
 include/RAJA/policy/sycl/params/reduce.hpp    | 36 ++-----
 6 files changed, 100 insertions(+), 136 deletions(-)

diff --git a/include/RAJA/policy/cuda/params/reduce.hpp b/include/RAJA/policy/cuda/params/reduce.hpp
index c3258acb0f..eab401032e 100644
--- a/include/RAJA/policy/cuda/params/reduce.hpp
+++ b/include/RAJA/policy/cuda/params/reduce.hpp
@@ -15,9 +15,9 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  init(Reducer<OP, T, ValOp<T,OP>>& red, RAJA::cuda::detail::cudaInfo& ci)
+  init(Reducer<OP, T, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
     red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
@@ -25,10 +25,10 @@ namespace detail {
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  combine(Reducer<OP, T, ValOp<T,OP>>& red)
+  combine(Reducer<OP, T, VType>& red)
   {
     RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP, T>(red.devicetarget,
                                                                             red.getVal(),
@@ -37,14 +37,14 @@ namespace detail {
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, ValOp<T,OP>>& red, RAJA::cuda::detail::cudaInfo& ci)
+  resolve(Reducer<OP, T, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
     // complete reduction
     ci.res.wait();
 
-    red.target->val = OP<T,T,T>{}(red.target->val, *red.devicetarget);
+    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
 
     // free memory
     RAJA::cuda::device_zeroed_mempool_type::getInstance().free(red.device_count);
diff --git a/include/RAJA/policy/hip/params/reduce.hpp b/include/RAJA/policy/hip/params/reduce.hpp
index 02905317c4..0d20d5afb7 100644
--- a/include/RAJA/policy/hip/params/reduce.hpp
+++ b/include/RAJA/policy/hip/params/reduce.hpp
@@ -13,9 +13,9 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  init(Reducer<OP, T, ValOp<T,OP>>& red, RAJA::hip::detail::hipInfo& hi)
+  init(Reducer<OP, T, VType>& red, RAJA::hip::detail::hipInfo& hi)
   {
     red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
@@ -23,10 +23,10 @@ namespace detail {
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  combine(Reducer<OP, T, ValOp<T,OP>>& red)
+  combine(Reducer<OP, T, VType>& red)
   {
     RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP,T>( red.devicetarget,
                                                                             red.getVal(),
@@ -35,13 +35,13 @@ namespace detail {
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, ValOp<T,OP>>& red, RAJA::hip::detail::hipInfo& hi)
+  resolve(Reducer<OP, T, VType>& red, RAJA::hip::detail::hipInfo& hi)
   {
     // complete reduction
     hi.res.wait();
-    red.target->val = OP<T,T,T>{}(red.target->val, *red.devicetarget);
+    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
 
     // free memory
     RAJA::hip::device_zeroed_mempool_type::getInstance().free(red.device_count);
diff --git a/include/RAJA/policy/openmp/params/reduce.hpp b/include/RAJA/policy/openmp/params/reduce.hpp
index 52ffc01697..7a0d95f9fc 100644
--- a/include/RAJA/policy/openmp/params/reduce.hpp
+++ b/include/RAJA/policy/openmp/params/reduce.hpp
@@ -9,53 +9,83 @@ namespace detail {
 
 #if defined(RAJA_ENABLE_OPENMP)
 
+/*
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
+           std::enable_if_t<std::is_same<T, RAJA::expt::ValLoc<int,RAJA::Index_type>>::value>* = nullptr >
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, ValOp<T,OP>>& red) {
+  init(Reducer<OP, T, VType>& red) {
     red.val.val = OP<T,T,T>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
+           std::enable_if_t<std::is_same<T, RAJA::expt::ValLoc<int,RAJA::Index_type>>::value>* = nullptr >
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, ValOp<T,OP>>& out, const Reducer<OP, T, ValOp<T,OP>>& in) {
+  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
     out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
+           std::enable_if_t<std::is_same<T, RAJA::expt::ValLoc<int,RAJA::Index_type>>::value>* = nullptr >
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, ValOp<T,OP>>& red) {
-    red.target->val = OP<T,T,T>{}(red.target->val, red.val.val);
+  resolve(Reducer<OP, T, VType>& red) {
+  //resolve(Reducer<OP, T, ValOp<ValLoc<T,U>,OP>>& red) {
+    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
   }
 
-//  // Init
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  //template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-//  init(Reducer<OP, T, T>& red) {
-//  //init(Reducer<OP, T>& red) {
-//    red.val = OP<T,T,T>::identity();
-//  }
-//
-//  // Combine
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  //template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-//  combine(Reducer<OP, T, T>& out, const Reducer<OP, T, T>& in) {
-//  //combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-//    out.val = OP<T,T,T>{}(out.val, in.val);
-//  }
-//
-//  // Resolve
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  //template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-//  resolve(Reducer<OP, T, T>& red) {
-//  //resolve(Reducer<OP, T>& red) {
-//    *red.target = OP<T,T,T>{}(*red.target, red.val);
-//  }
+  // Init
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
+           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value>* = nullptr >
+  //template<typename EXEC_POL, typename OP, typename T>
+  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+  init(Reducer<OP, T, VType>& red) {
+  //init(Reducer<OP, T>& red) {
+    red.val.val = OP<T,T,T>::identity();
+  }
+
+  // Combine
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
+           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value>* = nullptr >
+  //template<typename EXEC_POL, typename OP, typename T>
+  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+  //combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
+    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
+  }
+
+  // Resolve
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
+           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value>* = nullptr >
+  //template<typename EXEC_POL, typename OP, typename T>
+  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+  resolve(Reducer<OP, T, VType>& red) {
+  //resolve(Reducer<OP, T>& red) {
+    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
+  }
+*/
+
+  // Init
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+  init(Reducer<OP, T, VType>& red) {
+    red.val.val = OP<T,T,T>::identity();
+  }
+
+  // Combine
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
+  }
+
+  // Resolve
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+  resolve(Reducer<OP, T, VType>& red) {
+    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
+  }
 
 #endif
 
diff --git a/include/RAJA/policy/openmp_target/params/reduce.hpp b/include/RAJA/policy/openmp_target/params/reduce.hpp
index 784e1dc6fd..f7b26a6b83 100644
--- a/include/RAJA/policy/openmp_target/params/reduce.hpp
+++ b/include/RAJA/policy/openmp_target/params/reduce.hpp
@@ -10,47 +10,26 @@ namespace detail {
 #if defined(RAJA_ENABLE_TARGET_OPENMP)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, ValOp<T,OP>>& red) {
+  init(Reducer<OP, T, VType>& red) {
     red.val.val = OP<T,T,T>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, ValOp<T,OP>>& out, const Reducer<OP, T, ValOp<T,OP>>& in) {
+  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
     out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, ValOp<T,OP>>& red) {
-    red.target->val = OP<T,T,T>{}(red.target->val, red.val.val);
+  resolve(Reducer<OP, T, VType>& red) {
+    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
   }
 
-//  // Init
-//  template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-//  init(Reducer<OP, T>& red) {
-//    red.val = OP::identity();
-//  }
-//
-//  // Combine
-//  template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-//  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-//    out.val = OP{}(out.val, in.val);
-//  }
-//
-//  // Resolve
-//  template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-//  resolve(Reducer<OP, T>& red) {
-//    *red.target = OP{}(*red.target, red.val);
-//  }
-
 #endif
 
 } //  namespace detail
diff --git a/include/RAJA/policy/sequential/params/reduce.hpp b/include/RAJA/policy/sequential/params/reduce.hpp
index d0a64ba981..fef39eef9d 100644
--- a/include/RAJA/policy/sequential/params/reduce.hpp
+++ b/include/RAJA/policy/sequential/params/reduce.hpp
@@ -8,49 +8,26 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  init(Reducer<OP, T, ValOp<T,OP>>& red) {
+  init(Reducer<OP, T, VType>& red) {
     red.val.val = OP<T,T,T>::identity();
   }
+
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  combine(Reducer<OP, T, ValOp<T,OP>>& out, const Reducer<OP, T, ValOp<T,OP>>& in) {
+  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
     out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
   }
+
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  resolve(Reducer<OP, T, ValOp<T,OP>>& red) {
-    red.target->val = OP<T,T,T>{}(red.target->val, red.val.val);
+  resolve(Reducer<OP, T, VType>& red) {
+    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
   }
 
-//  // Init
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  //template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-//  init(Reducer<OP, T, T>& red) {
-//  //init(Reducer<OP, T>& red) {
-//    red.val = OP<T,T,T>::identity();
-//  }
-//  // Combine
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  //template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-//  combine(Reducer<OP, T, T>& out, const Reducer<OP, T, T>& in) {
-//  //combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-//    out.val = OP<T,T,T>{}(out.val, in.val);
-//  }
-//  // Resolve
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  //template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-//  resolve(Reducer<OP, T, T>& red) {
-//  //resolve(Reducer<OP, T>& red) {
-//    *red.target = OP<T,T,T>{}(*red.target, red.val);
-//  }
-
 } //  namespace detail
 } //  namespace expt
 } //  namespace RAJA
diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index eaf4b770b8..64f95a5a02 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -10,46 +10,24 @@ namespace detail {
 #if defined(RAJA_ENABLE_SYCL)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  init(Reducer<OP, T, ValOp<T,OP>>& red) {
+  init(Reducer<OP, T, VType>& red) {
     red.val.val = OP<T,T,T>::identity();
   }
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  combine(Reducer<OP, T, ValOp<T,OP>>& out, const Reducer<OP, T, ValOp<T,OP>>& in) {
+  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
     out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
   }
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, ValOp<T,OP>>& red) {
-    red.target->val = OP<T,T,T>{}(red.target->val, red.val.val);
+  resolve(Reducer<OP, T, VType>& red) {
+    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
   }
 
-//  // Init
-//  template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-//  init(Reducer<OP, T>& red) {
-//    red.val = OP::identity();
-//  }
-//
-//  // Combine
-//  template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-//  SYCL_EXTERNAL
-//  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-//    out.val = OP{}(out.val, in.val);
-//  }
-//
-//  // Resolve
-//  template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-//  resolve(Reducer<OP, T>& red) {
-//    *red.target = OP{}(*red.target, red.val);
-//  }
-
 #endif
 
 } //  namespace detail

From 69413c6c5473cb7da92b5e5b3560630760312685 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 13 Sep 2024 15:53:54 -0700
Subject: [PATCH 44/82] Update ValOp in tests.

---
 .../test-forall-basic-expt-ReduceBitAnd.hpp   | 24 +++++++++----------
 .../test-forall-basic-expt-ReduceBitOr.hpp    | 24 +++++++++----------
 .../test-forall-basic-expt-ReduceMax.hpp      | 24 +++++++++----------
 .../test-forall-basic-expt-ReduceMaxLoc.hpp   | 20 ++++++++--------
 .../test-forall-basic-expt-ReduceMin.hpp      | 24 +++++++++----------
 .../test-forall-basic-expt-ReduceMinLoc.hpp   | 21 ++++++++--------
 .../test-forall-basic-expt-ReduceSum.hpp      | 18 +++++++-------
 ...t-launch-basic-param-expt-ReduceBitAnd.hpp | 24 +++++++++----------
 ...test-launch-basic-param-expt-ReduceMin.hpp | 24 +++++++++----------
 ...test-launch-basic-param-expt-ReduceSum.hpp | 16 ++++++-------
 10 files changed, 109 insertions(+), 110 deletions(-)

diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp
index d675d4bd32..c64106fc59 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp
@@ -43,15 +43,15 @@ void ForallReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
   }
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  REF_BITAND simpand(21);
+  DATA_TYPE simpand(21);
 
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<>(&simpand),
+    RAJA::expt::Reduce<RAJA::operators::bit_and>(&simpand),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITAND & _simpand) {
       _simpand &= working_array[idx];
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(simpand.get()), 5);
+  ASSERT_EQ(static_cast<DATA_TYPE>(simpand), 5);
 
 
   //
@@ -70,33 +70,33 @@ void ForallReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
     ref_and &= test_array[ seg_idx[i] ];
   }
 
-  REF_BITAND redand(0);
-  REF_BITAND redand2(2);
+  DATA_TYPE redand(0);
+  DATA_TYPE redand2(2);
 
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<>(&redand),
-    RAJA::expt::Reduce<>(&redand2),
+    RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
+    RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand2),
     RAJA::expt::KernelName("RAJA Reduce BitAnd"),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITAND &r1, REF_BITAND &r2) {
       r1 &= working_array[idx];
       r2 &= working_array[idx];
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand.get()), ref_and);
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand2.get()), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand2), ref_and);
 
-  redand.set(0);
+  redand = 0;
 
   const int nloops = 3;
   for (int j = 0; j < nloops; ++j) {
     RAJA::forall<EXEC_POLICY>(seg,
-      RAJA::expt::Reduce<>(&redand),
+      RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
       [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITAND &r1) {
         r1 &= working_array[idx];
     });
   }
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand.get()), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand), ref_and);
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp
index e498f75e0d..8c3ea14c4d 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp
@@ -43,15 +43,15 @@ void ForallReduceBitOrBasicTestImpl(const SEG_TYPE& seg,
   }
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  REF_BITOR simpor(5);
+  DATA_TYPE simpor(5);
 
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<>(&simpor),
+    RAJA::expt::Reduce<RAJA::operators::bit_or>(&simpor),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITOR & _simpor) {
       _simpor |= working_array[idx];
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(simpor.get()), 13);
+  ASSERT_EQ(static_cast<DATA_TYPE>(simpor), 13);
 
  
   //
@@ -70,33 +70,33 @@ void ForallReduceBitOrBasicTestImpl(const SEG_TYPE& seg,
     ref_or |= test_array[ seg_idx[i] ];
   }
 
-  REF_BITOR redor(0);
-  REF_BITOR redor2(2);
+  DATA_TYPE redor(0);
+  DATA_TYPE redor2(2);
 
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<>(&redor),
-    RAJA::expt::Reduce<>(&redor2),
+    RAJA::expt::Reduce<RAJA::operators::bit_or>(&redor),
+    RAJA::expt::Reduce<RAJA::operators::bit_or>(&redor2),
     RAJA::expt::KernelName("RAJA Reduce BitOr"),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITOR &r1, REF_BITOR &r2) {
       r1 |= working_array[idx];
       r2 |= working_array[idx];
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redor.get()), ref_or);
-  ASSERT_EQ(static_cast<DATA_TYPE>(redor2.get()), ref_or);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redor), ref_or);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redor2), ref_or);
 
-  redor.set(0);
+  redor = 0;
 
   const int nloops = 3;
   for (int j = 0; j < nloops; ++j) {
     RAJA::forall<EXEC_POLICY>(seg,
-      RAJA::expt::Reduce<>(&redor),
+      RAJA::expt::Reduce<RAJA::operators::bit_or>(&redor),
       [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITOR &r1) {
         r1 |= working_array[idx];
     });
   }
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redor.get()), ref_or);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redor), ref_or);
    
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp
index e8dfe2092b..773c737a85 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp
@@ -50,39 +50,39 @@ void ForallReduceMaxBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  REF_MAX maxinit(big_max);
-  REF_MAX max(max_init);
+  DATA_TYPE maxinit(big_max);
+  DATA_TYPE max(max_init);
 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<>(&maxinit),
-    RAJA::expt::Reduce<>(&max),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&maxinit),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
     RAJA::expt::KernelName("RAJA Reduce Max"),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MAX &mi, REF_MAX &m) {
       mi.max(working_array[idx]);
       m.max(working_array[idx]);
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(maxinit.get()), big_max);
-  ASSERT_EQ(static_cast<DATA_TYPE>(max.get()), ref_max);
+  ASSERT_EQ(static_cast<DATA_TYPE>(maxinit), big_max);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max), ref_max);
 
-  max.set(max_init);
-  ASSERT_EQ(static_cast<DATA_TYPE>(max.get()), max_init);
+  max = max_init;
+  ASSERT_EQ(static_cast<DATA_TYPE>(max), max_init);
 
   DATA_TYPE factor = 2;
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<>(&max),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MAX &m) {
       m.max(working_array[idx] * factor);
   });
-  ASSERT_EQ(static_cast<DATA_TYPE>(max.get()), ref_max * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max), ref_max * factor);
    
   factor = 3;
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<>(&max),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MAX &m) {
       m.max(working_array[idx] * factor);
   });
-  ASSERT_EQ(static_cast<DATA_TYPE>(max.get()), ref_max * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max), ref_max * factor);
    
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
index 4da9647194..80be078094 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
@@ -57,15 +57,16 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
 
-  using VL_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::maximum>;
+  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE, IDX_TYPE>;
+  using VL_LAMBDA_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::maximum>;
   VL_TYPE maxinit(big_max, maxloc_init);
   VL_TYPE max(max_init, maxloc_init);
 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<>(&maxinit),
-    RAJA::expt::Reduce<>(&max),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&maxinit),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
     RAJA::expt::KernelName("RAJA Reduce MaxLoc"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &mi, VL_TYPE &m) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &mi, VL_LAMBDA_TYPE &m) {
       mi.maxloc( working_array[idx], idx );
       m.maxloc( working_array[idx], idx );
   });
@@ -75,15 +76,14 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
 
-  max.setVal(max_init);
-  max.setLoc(maxloc_init);
+  max.set(max_init, maxloc_init);
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), max_init);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), maxloc_init);
 
   DATA_TYPE factor = 2;
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<>(&max),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
       m.maxloc( working_array[idx] * factor, idx);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
@@ -91,8 +91,8 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   
   factor = 3;
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<>(&max),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
       m.maxloc( working_array[idx] * factor, idx);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp
index 29235a9bcb..9aab696301 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp
@@ -50,39 +50,39 @@ void ForallReduceMinBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  REF_MIN mininit(small_min);
-  REF_MIN min(min_init);
+  DATA_TYPE mininit(small_min);
+  DATA_TYPE min(min_init);
 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<>(&mininit),
-    RAJA::expt::Reduce<>(&min),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
     RAJA::expt::KernelName("RAJA Reduce Min"),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MIN &mi, REF_MIN &m) {
       mi.min(working_array[idx]);
       m.min(working_array[idx]);
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(mininit.get()), small_min);
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min);
+  ASSERT_EQ(static_cast<DATA_TYPE>(mininit), small_min);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min);
 
-  min.set(min_init);
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), min_init);
+  min = min_init;
+  ASSERT_EQ(static_cast<DATA_TYPE>(min), min_init);
 
   DATA_TYPE factor = 3; 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<>(&min),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MIN &m) {
       m.min(working_array[idx] * factor);
   });
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min * factor);
 
   factor = 2;
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<>(&min),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MIN &m) {
       m.min(working_array[idx] * factor);
   });
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min * factor);
 
   deallocateForallTestData<DATA_TYPE>(working_res,
                                       working_array,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
index 5ac1311c12..be580df1c9 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
@@ -56,16 +56,16 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-
-  using VL_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::minimum>;
+  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE, IDX_TYPE>;
+  using VL_LAMBDA_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::minimum>;
   VL_TYPE mininit(small_min, minloc_init);
   VL_TYPE min(min_init, minloc_init);
 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<>(&mininit),
-    RAJA::expt::Reduce<>(&min),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
     RAJA::expt::KernelName("RAJA Reduce MinLoc"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &mi, VL_TYPE &m) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &mi, VL_LAMBDA_TYPE &m) {
       mi.minloc( working_array[idx], idx );
       m.minloc( working_array[idx], idx );
   });
@@ -75,15 +75,14 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
 
-  min.setVal(min_init);
-  min.setLoc(minloc_init);
+  min.set(min_init, minloc_init);
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), min_init);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), minloc_init);
 
   DATA_TYPE factor = 2;
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<>(&min),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
       m.minloc( working_array[idx] * factor, idx);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
@@ -91,8 +90,8 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
 
   factor = 3;
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<>(&min),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
       m.minloc( working_array[idx] * factor, idx);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
index ba672c4bd5..4105700f7c 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
@@ -48,34 +48,34 @@ void ForallReduceSumBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  REF_SUM sum(0);
-  REF_SUM sum2(2);
+  DATA_TYPE sum(0);
+  DATA_TYPE sum2(2);
 
   RAJA::forall<EXEC_POLICY>(seg, 
-    RAJA::expt::Reduce<>(&sum),
-    RAJA::expt::Reduce<>(&sum2),
+    RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
+    RAJA::expt::Reduce<RAJA::operators::plus>(&sum2),
     RAJA::expt::KernelName("RAJA Reduce Sum"),
     [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_SUM &s1, REF_SUM &s2) {
       s1 += working_array[idx];
       s2 += working_array[idx];
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum.get()), ref_sum);
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum2.get()), ref_sum + 2);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum), ref_sum);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum2), ref_sum + 2);
 
-  sum.set(0);
+  sum = 0;
 
   const int nloops = 2;
 
   for (int j = 0; j < nloops; ++j) {
     RAJA::forall<EXEC_POLICY>(seg, 
-      RAJA::expt::Reduce<>(&sum),
+      RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
       [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_SUM &s) {
         s += working_array[idx];
     });
   }
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum.get()), nloops * ref_sum);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum), nloops * ref_sum);
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp
index 59c0a17ba3..0a91d5f9b8 100644
--- a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp
+++ b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp
@@ -48,11 +48,11 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
   }
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  REF_BITAND simpand(21);
+  DATA_TYPE simpand(21);
 
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-     RAJA::expt::Reduce<>(&simpand),
+     RAJA::expt::Reduce<RAJA::operators::bit_and>(&simpand),
      [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_BITAND &_simpand) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
@@ -62,7 +62,7 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
 
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(simpand.get()), 5);
+  ASSERT_EQ(static_cast<DATA_TYPE>(simpand), 5);
 
 
   //
@@ -81,13 +81,13 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
     ref_and &= test_array[ seg_idx[i] ];
   }
 
-  REF_BITAND redand(0);
-  REF_BITAND redand2(2);
+  DATA_TYPE redand(0);
+  DATA_TYPE redand2(2);
 
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-     RAJA::expt::Reduce<>(&redand),
-     RAJA::expt::Reduce<>(&redand2),
+     RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
+     RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand2),
      [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_BITAND &_redand, REF_BITAND &_redand2) {
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
         _redand  &= working_array[idx];
@@ -95,16 +95,16 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
     });
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand.get()), ref_and);
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand2.get()), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand2), ref_and);
 
-  redand.set(0);
+  redand = 0;
 
   const int nloops = 3;
   for (int j = 0; j < nloops; ++j) {
     RAJA::launch<LAUNCH_POLICY>
       (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-       RAJA::expt::Reduce<>(&redand),
+       RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
        [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_BITAND _redand) {
         RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
           _redand &= working_array[idx];
@@ -112,7 +112,7 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
     });
   }
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(redand.get()), ref_and);
+  ASSERT_EQ(static_cast<DATA_TYPE>(redand), ref_and);
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp
index 9107aac69d..91ab75dbab 100644
--- a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp
+++ b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp
@@ -54,14 +54,14 @@ void LaunchParamExptReduceMinBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  REF_MIN mininit(small_min);
-  REF_MIN min(min_init);
+  DATA_TYPE mininit(small_min);
+  DATA_TYPE min(min_init);
   
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
      "LaunchMinBasicTest",
-     RAJA::expt::Reduce<>(&mininit),
-     RAJA::expt::Reduce<>(&min),
+     RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
+     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
      [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_MIN &_mininit, REF_MIN &_min) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
@@ -74,16 +74,16 @@ void LaunchParamExptReduceMinBasicTestImpl(const SEG_TYPE& seg,
   });
 
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(mininit.get()), small_min);
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min);
+  ASSERT_EQ(static_cast<DATA_TYPE>(mininit), small_min);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min);
 
-  min.set(min_init);
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), min_init);
+  min = min_init;
+  ASSERT_EQ(static_cast<DATA_TYPE>(min), min_init);
 
   DATA_TYPE factor = 3;
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-     RAJA::expt::Reduce<>(&min),
+     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
      [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_MIN &_min) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
@@ -93,13 +93,13 @@ void LaunchParamExptReduceMinBasicTestImpl(const SEG_TYPE& seg,
 
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min * factor);
 
 
   factor = 2;
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-     RAJA::expt::Reduce<>(&min),
+     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
      [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_MIN &_min) {
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
 
@@ -107,7 +107,7 @@ void LaunchParamExptReduceMinBasicTestImpl(const SEG_TYPE& seg,
       });
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.get()), ref_min * factor);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min * factor);
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp
index 4339026a64..f6200628cf 100644
--- a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp
+++ b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp
@@ -53,13 +53,13 @@ void LaunchParamExptReduceSumBasicTestImpl(const SEG_TYPE& seg,
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
 
-  REF_SUM sum(0), sum2(2);
+  DATA_TYPE sum(0), sum2(2);
 
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
      "LaunchSumBasicTest",
-     RAJA::expt::Reduce<>(&sum),
-     RAJA::expt::Reduce<>(&sum2),
+     RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
+     RAJA::expt::Reduce<RAJA::operators::plus>(&sum2),
      [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_SUM &_sum, REF_SUM &_sum2) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
@@ -69,17 +69,17 @@ void LaunchParamExptReduceSumBasicTestImpl(const SEG_TYPE& seg,
 
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum.get()), ref_sum);
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum2.get()), ref_sum + 2);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum), ref_sum);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum2), ref_sum + 2);
 
-  sum.set(0);
+  sum = 0;
 
   const int nloops = 2;
 
   for (int j = 0; j < nloops; ++j) {
     RAJA::launch<LAUNCH_POLICY>
       (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
-       RAJA::expt::Reduce<>(&sum),
+       RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
        [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_SUM &_sum) {
 
         RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
@@ -88,7 +88,7 @@ void LaunchParamExptReduceSumBasicTestImpl(const SEG_TYPE& seg,
       });
   }
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(sum.get()), nloops * ref_sum);
+  ASSERT_EQ(static_cast<DATA_TYPE>(sum), nloops * ref_sum);
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,

From 54f2f882d058f80b8891e436ea52905d70e49f93 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 13 Sep 2024 15:54:12 -0700
Subject: [PATCH 45/82] Update ValOp in examples.

---
 examples/forall-param-reductions.cpp | 211 +++++++++++----------------
 examples/launch-param-reductions.cpp | 135 ++++++++---------
 2 files changed, 150 insertions(+), 196 deletions(-)

diff --git a/examples/forall-param-reductions.cpp b/examples/forall-param-reductions.cpp
index 9c2d4356ad..5dfcb6411f 100644
--- a/examples/forall-param-reductions.cpp
+++ b/examples/forall-param-reductions.cpp
@@ -85,7 +85,7 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 // Note: with this data initialization scheme, the following results will
 //       be observed for all reduction kernels below:
 //
-//  - the sum will be zero
+//  - the sum will be two
 //  - the min will be -100
 //  - the max will be 100
 //  - the min loc will be N/2
@@ -104,8 +104,18 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 // Define ValLoc Type
 //
 
-/*
   using VALLOC_INT = RAJA::expt::ValLoc<int, RAJA::Index_type>;
+
+//
+// Define ValLoc Safe Type
+//
+
+  using REF_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
+  using REF_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
+  using REF_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
+  using REFLOC_INT_MIN = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::minimum>;
+  using REFLOC_INT_MAX = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::maximum>;
+
 //----------------------------------------------------------------------------//
 
   std::cout << "\n Running RAJA sequential reductions...\n";
@@ -126,19 +136,14 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_maxloc),
     RAJA::expt::KernelName("RAJA Reduce Seq Kernel"),
-    [=](int i, int &_seq_sum, int &_seq_min, int &_seq_max, VALLOC_INT &_seq_minloc, VALLOC_INT &_seq_maxloc) {
+    [=](int i, REF_INT_SUM &_seq_sum, REF_INT_MIN &_seq_min, REF_INT_MAX &_seq_max, REFLOC_INT_MIN &_seq_minloc, REFLOC_INT_MAX &_seq_maxloc) {
       _seq_sum += a[i];
 
-      _seq_min = RAJA_MIN(a[i], _seq_min);
-      _seq_max = RAJA_MAX(a[i], _seq_max);
+      _seq_min.min(a[i]);
+      _seq_max.max(a[i]);
 
-      _seq_minloc = RAJA_MIN(VALLOC_INT(a[i], i), _seq_minloc);
-      _seq_maxloc = RAJA_MAX(VALLOC_INT(a[i], i), _seq_maxloc);
-      //_seq_minloc.min(a[i], i);
-      //_seq_maxloc.max(a[i], i);
-      // Note : RAJA::expt::ValLoc<T> objects provide min() and max() methods
-      //        that are equivalent to the assignments with RAJA_MIN and RAJA_MAX
-      //        above.
+      _seq_minloc.minloc(a[i], i);
+      _seq_maxloc.maxloc(a[i], i);
     }
   );
 
@@ -150,58 +155,6 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   std::cout << "\tmax, loc = " << seq_maxloc.getVal() << " , "
                                << seq_maxloc.getLoc() << std::endl;
   // _reductions_raja_seq_end
-*/
-
-
-//
-// Define ValLoc Safe Type
-//
-
-  using REF_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
-  using REF_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
-  using REF_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
-  using REFLOC_INT_MIN = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::minimum>;
-  using REFLOC_INT_MAX = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::maximum>;
-//----------------------------------------------------------------------------//
-
-  std::cout << "\n Running RAJA sequential safe reductions...\n";
-
-  using EXEC_POL1S   = RAJA::seq_exec;
-
-  REF_INT_SUM sseq_sum(0);
-  REF_INT_MIN sseq_min(std::numeric_limits<int>::max());
-  REF_INT_MAX sseq_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN sseq_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX sseq_maxloc(std::numeric_limits<int>::min(), -1);
-
-  RAJA::forall<EXEC_POL1S>(host_res, arange,
-    RAJA::expt::Reduce<>(&sseq_sum),
-    RAJA::expt::Reduce<>(&sseq_min),
-    RAJA::expt::Reduce<>(&sseq_max),
-    RAJA::expt::Reduce<>(&sseq_minloc),
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&sseq_maxloc),
-    RAJA::expt::KernelName("RAJA Reduce Seq Safe Kernel"),
-    [=](int i, REF_INT_SUM &_sseq_sum, REF_INT_MIN &_sseq_min, REF_INT_MAX &_sseq_max, REFLOC_INT_MIN &_sseq_minloc, REFLOC_INT_MAX &_sseq_maxloc) {
-      _sseq_sum += a[i];
-
-      _sseq_min.min(a[i]);
-      _sseq_max.max(a[i]);
-
-      _sseq_minloc.minloc(a[i], i);
-      _sseq_maxloc.maxloc(a[i], i);
-      // Note : RAJA::expt::ValLoc<T> objects provide min() and max() methods
-      //        that are equivalent to the assignments with RAJA_MIN and RAJA_MAX
-      //        above.
-    }
-  );
-
-  std::cout << "\tsum = " << sseq_sum.get() << std::endl;
-  std::cout << "\tmin = " << sseq_min.get() << std::endl;
-  std::cout << "\tmax = " << sseq_max.get() << std::endl;
-  std::cout << "\tmin, loc = " << sseq_minloc.getVal() << " , "
-                               << sseq_minloc.getLoc() << std::endl;
-  std::cout << "\tmax, loc = " << sseq_maxloc.getVal() << " , "
-                               << sseq_maxloc.getLoc() << std::endl;
 
 
 //----------------------------------------------------------------------------//
@@ -213,18 +166,18 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using EXEC_POL2   = RAJA::omp_parallel_for_exec;
   // _reductions_raja_omppolicy_end
 
-  REF_INT_SUM omp_sum(0);
-  REF_INT_MIN omp_min(std::numeric_limits<int>::max());
-  REF_INT_MAX omp_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN omp_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX omp_maxloc(std::numeric_limits<int>::min(), -1);
+  int omp_sum = 0;
+  int omp_min = std::numeric_limits<int>::max();
+  int omp_max = std::numeric_limits<int>::min();
+  VALLOC_INT omp_minloc(std::numeric_limits<int>::max(), -1);
+  VALLOC_INT omp_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::forall<EXEC_POL2>(host_res, arange,
-    RAJA::expt::Reduce<>(&omp_sum),
-    RAJA::expt::Reduce<>(&omp_min),
-    RAJA::expt::Reduce<>(&omp_max),
-    RAJA::expt::Reduce<>(&omp_minloc),
-    RAJA::expt::Reduce<>(&omp_maxloc),
+    RAJA::expt::Reduce<RAJA::operators::plus>(&omp_sum),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_min),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_max),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_maxloc),
     RAJA::expt::KernelName("RAJA Reduce OpenMP Kernel"),
     [=](int i, REF_INT_SUM &_omp_sum, REF_INT_MIN &_omp_min, REF_INT_MAX &_omp_max, REFLOC_INT_MIN &_omp_minloc, REFLOC_INT_MAX &_omp_maxloc) {
       _omp_sum += a[i];
@@ -237,9 +190,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << omp_sum.get() << std::endl;
-  std::cout << "\tmin = " << omp_min.get() << std::endl;
-  std::cout << "\tmax = " << omp_max.get() << std::endl;
+  std::cout << "\tsum = " << omp_sum << std::endl;
+  std::cout << "\tmin = " << omp_min << std::endl;
+  std::cout << "\tmax = " << omp_max << std::endl;
   std::cout << "\tmin, loc = " << omp_minloc.getVal() << " , "
                                << omp_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << omp_maxloc.getVal() << " , "
@@ -258,18 +211,18 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using EXEC_POL3   = RAJA::omp_target_parallel_for_exec_nt;
   // _reductions_raja_omppolicy_end
 
-  REF_INT_SUM omp_t_sum(0);
-  REF_INT_MIN omp_t_min(std::numeric_limits<int>::max());
-  REF_INT_MAX omp_t_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN omp_t_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX omp_t_maxloc(std::numeric_limits<int>::min(), -1);
+  int omp_t_sum = 0;
+  int omp_t_min = std::numeric_limits<int>::max();
+  int omp_t_max = std::numeric_limits<int>::min();
+  VALLOC_INT omp_t_minloc(std::numeric_limits<int>::max(), -1);
+  VALLOC_INT omp_t_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::forall<EXEC_POL3>(omp_res, arange,
-    RAJA::expt::Reduce<>(&omp_t_sum),
-    RAJA::expt::Reduce<>(&omp_t_min),
-    RAJA::expt::Reduce<>(&omp_t_max),
-    RAJA::expt::Reduce<>(&omp_t_minloc),
-    RAJA::expt::Reduce<>(&omp_t_maxloc),
+    RAJA::expt::Reduce<RAJA::operators::plus>(&omp_t_sum),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_t_min),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_t_max),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_t_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_t_maxloc),
     RAJA::expt::KernelName("RAJA Reduce Target OpenMP Kernel"),
     [=](int i, REF_INT_SUM &_omp_t_sum, REF_INT_MIN &_omp_t_min, REF_INT_MAX &_omp_t_max, REFLOC_INT_MIN &_omp_t_minloc, REFLOC_INT_MAX &_omp_t_maxloc) {
       _omp_t_sum += a[i];
@@ -282,9 +235,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << omp_t_sum.get() << std::endl;
-  std::cout << "\tmin = " << omp_t_min.get() << std::endl;
-  std::cout << "\tmax = " << omp_t_max.get() << std::endl;
+  std::cout << "\tsum = " << omp_t_sum << std::endl;
+  std::cout << "\tmin = " << omp_t_min << std::endl;
+  std::cout << "\tmax = " << omp_t_max << std::endl;
   std::cout << "\tmin, loc = " << omp_t_minloc.getVal() << " , "
                                << omp_t_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << omp_t_maxloc.getVal() << " , "
@@ -307,18 +260,18 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using EXEC_POL3   = RAJA::cuda_exec<CUDA_BLOCK_SIZE>;
   // _reductions_raja_cudapolicy_end
 
-  REF_INT_SUM cuda_sum(0);
-  REF_INT_MIN cuda_min(std::numeric_limits<int>::max());
-  REF_INT_MAX cuda_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN cuda_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX cuda_maxloc(std::numeric_limits<int>::min(), -1);
+  int cuda_sum = 0;
+  int cuda_min = std::numeric_limits<int>::max();
+  int cuda_max = std::numeric_limits<int>::min();
+  VALLOC_INT cuda_minloc(std::numeric_limits<int>::max(), -1);
+  VALLOC_INT cuda_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::forall<EXEC_POL3>(cuda_res, arange,
-    RAJA::expt::Reduce<>(&cuda_sum),
-    RAJA::expt::Reduce<>(&cuda_min),
-    RAJA::expt::Reduce<>(&cuda_max),
-    RAJA::expt::Reduce<>(&cuda_minloc),
-    RAJA::expt::Reduce<>(&cuda_maxloc),
+    RAJA::expt::Reduce<RAJA::operators::plus>(&cuda_sum),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_min),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_max),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_maxloc),
     RAJA::expt::KernelName("RAJA Reduce CUDA Kernel"),
     [=] RAJA_DEVICE (int i, REF_INT_SUM &_cuda_sum, REF_INT_MIN &_cuda_min, REF_INT_MAX &_cuda_max, REFLOC_INT_MIN &_cuda_minloc, REFLOC_INT_MAX &_cuda_maxloc) {
       _cuda_sum += d_a[i];
@@ -331,9 +284,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << cuda_sum.get() << std::endl;
-  std::cout << "\tmin = " << cuda_min.get() << std::endl;
-  std::cout << "\tmax = " << cuda_max.get() << std::endl;
+  std::cout << "\tsum = " << cuda_sum << std::endl;
+  std::cout << "\tmin = " << cuda_min << std::endl;
+  std::cout << "\tmax = " << cuda_max << std::endl;
   std::cout << "\tmin, loc = " << cuda_minloc.getVal() << " , "
                                << cuda_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << cuda_maxloc.getVal() << " , "
@@ -355,18 +308,18 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using EXEC_POL3   = RAJA::hip_exec<HIP_BLOCK_SIZE>;
   // _reductions_raja_hippolicy_end
 
-  REF_INT_SUM hip_sum(0);
-  REF_INT_MIN hip_min(std::numeric_limits<int>::max());
-  REF_INT_MAX hip_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN hip_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX hip_maxloc(std::numeric_limits<int>::min(), -1);
+  int hip_sum = 0;
+  int hip_min = std::numeric_limits<int>::max();
+  int hip_max = std::numeric_limits<int>::min();
+  VALLOC_INT hip_minloc(std::numeric_limits<int>::max(), -1);
+  VALLOC_INT hip_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::forall<EXEC_POL3>(hip_res, arange,
-    RAJA::expt::Reduce<>(&hip_sum),
-    RAJA::expt::Reduce<>(&hip_min),
-    RAJA::expt::Reduce<>(&hip_max),
-    RAJA::expt::Reduce<>(&hip_minloc),
-    RAJA::expt::Reduce<>(&hip_maxloc),
+    RAJA::expt::Reduce<RAJA::operators::plus>(&hip_sum),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_min),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_max),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_maxloc),
     RAJA::expt::KernelName("RAJA Reduce HIP Kernel"),
     [=] RAJA_DEVICE (int i, REF_INT_SUM &_hip_sum, REF_INT_MIN &_hip_min, REF_INT_MAX &_hip_max, REFLOC_INT_MIN &_hip_minloc, REFLOC_INT_MAX &_hip_maxloc) {
       _hip_sum += d_a[i];
@@ -379,9 +332,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << hip_sum.get() << std::endl;
-  std::cout << "\tmin = " << hip_min.get() << std::endl;
-  std::cout << "\tmax = " << hip_max.get() << std::endl;
+  std::cout << "\tsum = " << hip_sum << std::endl;
+  std::cout << "\tmin = " << hip_min << std::endl;
+  std::cout << "\tmax = " << hip_max << std::endl;
   std::cout << "\tmin, loc = " << hip_minloc.getVal() << " , "
                                << hip_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << hip_maxloc.getVal() << " , "
@@ -404,18 +357,18 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using EXEC_POL3   = RAJA::sycl_exec<SYCL_BLOCK_SIZE>;
   // _reductions_raja_syclpolicy_end
 
-  REF_INT_SUM sycl_sum(0);
-  REF_INT_MIN sycl_min(std::numeric_limits<int>::max());
-  REF_INT_MAX sycl_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN sycl_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX sycl_maxloc(std::numeric_limits<int>::min(), -1);
+  int sycl_sum = 0;
+  int sycl_min = std::numeric_limits<int>::max();
+  int sycl_max = std::numeric_limits<int>::min();
+  VALLOC_INT sycl_minloc(std::numeric_limits<int>::max(), -1);
+  VALLOC_INT sycl_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::forall<EXEC_POL3>(sycl_res, arange,
-    RAJA::expt::Reduce<>(&sycl_sum),
-    RAJA::expt::Reduce<>(&sycl_min),
-    RAJA::expt::Reduce<>(&sycl_max),
-    RAJA::expt::Reduce<>(&sycl_minloc),
-    RAJA::expt::Reduce<>(&sycl_maxloc),
+    RAJA::expt::Reduce<RAJA::operators::plus>(&sycl_sum),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_min),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_max),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_maxloc),
     RAJA::expt::KernelName("RAJA Reduce SYCL Kernel"),
     [=] RAJA_DEVICE (int i, REF_INT_SUM &_sycl_sum, REF_INT_MIN &_sycl_min, REF_INT_MAX &_sycl_max, REFLOC_INT_MIN &_sycl_minloc, REFLOC_INT_MAX &_sycl_maxloc) {
       _sycl_sum += d_a[i];
@@ -428,9 +381,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << sycl_sum.get() << std::endl;
-  std::cout << "\tmin = " << sycl_min.get() << std::endl;
-  std::cout << "\tmax = " << sycl_max.get() << std::endl;
+  std::cout << "\tsum = " << sycl_sum << std::endl;
+  std::cout << "\tmin = " << sycl_min << std::endl;
+  std::cout << "\tmax = " << sycl_max << std::endl;
   std::cout << "\tmin, loc = " << sycl_minloc.getVal() << " , "
                                << sycl_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << sycl_maxloc.getVal() << " , "
diff --git a/examples/launch-param-reductions.cpp b/examples/launch-param-reductions.cpp
index d49e859791..176d34cc24 100644
--- a/examples/launch-param-reductions.cpp
+++ b/examples/launch-param-reductions.cpp
@@ -100,7 +100,7 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 // Note: with this data initialization scheme, the following results will
 //       be observed for all reduction kernels below:
 //
-//  - the sum will be zero
+//  - the sum will be two
 //  - the min will be -100
 //  - the max will be 100
 //  - the min loc will be N/2
@@ -119,7 +119,8 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 // Define ValLoc Type
 //
 
-  //using VALLOC_INT = RAJA::expt::ValLoc<int>;
+  using VALLOC_INT = RAJA::expt::ValLoc<int>;
+
   using REF_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
   using REF_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
   using REF_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
@@ -133,19 +134,19 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using LAUNCH_POL1   = RAJA::LaunchPolicy<RAJA::seq_launch_t>;
   using LOOP_POL1     = RAJA::LoopPolicy<RAJA::seq_exec>;
 
-  REF_INT_SUM seq_sum(0);
-  REF_INT_MIN seq_min(std::numeric_limits<int>::max());
-  REF_INT_MAX seq_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN seq_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX seq_maxloc(std::numeric_limits<int>::min(), -1);
+  int seq_sum = 0;
+  int seq_min = std::numeric_limits<int>::max();
+  int seq_max = std::numeric_limits<int>::min();
+  VALLOC_INT seq_minloc(std::numeric_limits<int>::max(), -1);
+  VALLOC_INT seq_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::launch<LAUNCH_POL1>
     (host_res, RAJA::LaunchParams(), "SeqReductionKernel",
-    RAJA::expt::Reduce<>(&seq_sum),
-    RAJA::expt::Reduce<>(&seq_min),
-    RAJA::expt::Reduce<>(&seq_max),
-    RAJA::expt::Reduce<>(&seq_minloc),
-    RAJA::expt::Reduce<>(&seq_maxloc),
+    RAJA::expt::Reduce<RAJA::operators::plus   >(&seq_sum),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_min),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_max),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_maxloc),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
                            REF_INT_SUM &_seq_sum,
                            REF_INT_MIN &_seq_min,
@@ -171,9 +172,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << seq_sum.get() << std::endl;
-  std::cout << "\tmin = " << seq_min.get() << std::endl;
-  std::cout << "\tmax = " << seq_max.get() << std::endl;
+  std::cout << "\tsum = " << seq_sum << std::endl;
+  std::cout << "\tmin = " << seq_min << std::endl;
+  std::cout << "\tmax = " << seq_max << std::endl;
   std::cout << "\tmin, loc = " << seq_minloc.getVal() << " , "
                                << seq_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << seq_maxloc.getVal() << " , "
@@ -191,19 +192,19 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using LOOP_POL2     = RAJA::LoopPolicy<RAJA::omp_for_exec>;
   // _reductions_raja_omppolicy_end
 
-  REF_INT_SUM omp_sum(0);
-  REF_INT_MIN omp_min(std::numeric_limits<int>::max());
-  REF_INT_MAX omp_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN omp_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX omp_maxloc(std::numeric_limits<int>::min(), -1);
+  int omp_sum = 0;
+  int omp_min = std::numeric_limits<int>::max();
+  int omp_max = std::numeric_limits<int>::min();
+  VALLOC_INT omp_minloc(std::numeric_limits<int>::max(), -1);
+  VALLOC_INT omp_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::launch<LAUNCH_POL2>
     (host_res, RAJA::LaunchParams(), "OmpReductionKernel",
-    RAJA::expt::Reduce<>(&omp_sum),
-    RAJA::expt::Reduce<>(&omp_min),
-    RAJA::expt::Reduce<>(&omp_max),
-    RAJA::expt::Reduce<>(&omp_minloc),
-    RAJA::expt::Reduce<>(&omp_maxloc),
+    RAJA::expt::Reduce<RAJA::operators::plus   >(&omp_sum),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_min),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_max),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_maxloc),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
                            REF_INT_SUM &_omp_sum,
                            REF_INT_MIN &_omp_min,
@@ -226,9 +227,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << omp_sum.get() << std::endl;
-  std::cout << "\tmin = " << omp_min.get() << std::endl;
-  std::cout << "\tmax = " << omp_max.get() << std::endl;
+  std::cout << "\tsum = " << omp_sum << std::endl;
+  std::cout << "\tmin = " << omp_min << std::endl;
+  std::cout << "\tmax = " << omp_max << std::endl;
   std::cout << "\tmin, loc = " << omp_minloc.getVal() << " , "
                                << omp_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << omp_maxloc.getVal() << " , "
@@ -251,20 +252,20 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
   const int NUMBER_OF_TEAMS = (N-1)/CUDA_BLOCK_SIZE + 1;
 
-  REF_INT_SUM cuda_sum(0);
-  REF_INT_MIN cuda_min(std::numeric_limits<int>::max());
-  REF_INT_MAX cuda_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN cuda_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX cuda_maxloc(std::numeric_limits<int>::min(), -1);
+  int cuda_sum = 0;
+  int cuda_min = std::numeric_limits<int>::max();
+  int cuda_max = std::numeric_limits<int>::min();
+  VALLOC_INT cuda_minloc(std::numeric_limits<int>::max(), -1);
+  VALLOC_INT cuda_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::launch<LAUNCH_POL3>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(CUDA_BLOCK_SIZE)),
      "CUDAReductionKernel",
-    RAJA::expt::Reduce<>(&cuda_sum),
-    RAJA::expt::Reduce<>(&cuda_min),
-    RAJA::expt::Reduce<>(&cuda_max),
-    RAJA::expt::Reduce<>(&cuda_minloc),
-    RAJA::expt::Reduce<>(&cuda_maxloc),
+    RAJA::expt::Reduce<RAJA::operators::plus   >(&cuda_sum),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_min),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_max),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_maxloc),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
                            REF_INT_SUM &_cuda_sum,
                            REF_INT_MIN &_cuda_min,
@@ -290,9 +291,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << cuda_sum.get() << std::endl;
-  std::cout << "\tmin = " << cuda_min.get() << std::endl;
-  std::cout << "\tmax = " << cuda_max.get() << std::endl;
+  std::cout << "\tsum = " << cuda_sum << std::endl;
+  std::cout << "\tmin = " << cuda_min << std::endl;
+  std::cout << "\tmax = " << cuda_max << std::endl;
   std::cout << "\tmin, loc = " << cuda_minloc.getVal() << " , "
                                << cuda_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << cuda_maxloc.getVal() << " , "
@@ -316,20 +317,20 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
   const int NUMBER_OF_TEAMS = (N-1)/HIP_BLOCK_SIZE + 1;
 
-  REF_INT_SUM hip_sum(0);
-  REF_INT_MIN hip_min(std::numeric_limits<int>::max());
-  REF_INT_MAX hip_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN hip_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX hip_maxloc(std::numeric_limits<int>::min(), -1);
+  int hip_sum = 0;
+  int hip_min = std::numeric_limits<int>::max();
+  int hip_max = std::numeric_limits<int>::min();
+  VALLOC_INT hip_minloc(std::numeric_limits<int>::max(), -1);
+  VALLOC_INT hip_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::launch<LAUNCH_POL3>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(HIP_BLOCK_SIZE)),
      "HipReductionKernel",
-    RAJA::expt::Reduce<>(&hip_sum),
-    RAJA::expt::Reduce<>(&hip_min),
-    RAJA::expt::Reduce<>(&hip_max),
-    RAJA::expt::Reduce<>(&hip_minloc),
-    RAJA::expt::Reduce<>(&hip_maxloc),
+    RAJA::expt::Reduce<RAJA::operators::plus   >(&hip_sum),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_min),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_max),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_maxloc),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
                            REF_INT_SUM &_hip_sum,
                            REF_INT_MIN &_hip_min,
@@ -353,9 +354,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << hip_sum.get() << std::endl;
-  std::cout << "\tmin = " << hip_min.get() << std::endl;
-  std::cout << "\tmax = " << hip_max.get() << std::endl;
+  std::cout << "\tsum = " << hip_sum << std::endl;
+  std::cout << "\tmin = " << hip_min << std::endl;
+  std::cout << "\tmax = " << hip_max << std::endl;
   std::cout << "\tmin, loc = " << hip_minloc.getVal() << " , "
                                << hip_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << hip_maxloc.getVal() << " , "
@@ -379,20 +380,20 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
   const int NUMBER_OF_TEAMS = (N-1)/SYCL_BLOCK_SIZE + 1;
 
-  REF_INT_SUM sycl_sum(0);
-  REF_INT_MIN sycl_min(std::numeric_limits<int>::max());
-  REF_INT_MAX sycl_max(std::numeric_limits<int>::min());
-  REFLOC_INT_MIN sycl_minloc(std::numeric_limits<int>::max(), -1);
-  REFLOC_INT_MAX sycl_maxloc(std::numeric_limits<int>::min(), -1);
+  int sycl_sum = 0;
+  int sycl_min = std::numeric_limits<int>::max();
+  int sycl_max = std::numeric_limits<int>::min();
+  VALLOC_INT sycl_minloc(std::numeric_limits<int>::max(), -1);
+  VALLOC_INT sycl_maxloc(std::numeric_limits<int>::min(), -1);
 
   RAJA::launch<LAUNCH_POL4>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(SYCL_BLOCK_SIZE)),
      "SyclReductionKernel",
-    RAJA::expt::Reduce<>(&sycl_sum),
-    RAJA::expt::Reduce<>(&sycl_min),
-    RAJA::expt::Reduce<>(&sycl_max),
-    RAJA::expt::Reduce<>(&sycl_minloc),
-    RAJA::expt::Reduce<>(&sycl_maxloc),
+    RAJA::expt::Reduce<RAJA::operators::plus   >(&sycl_sum),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_min),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_max),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_minloc),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_maxloc),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
                            REF_INT_SUM &_sycl_sum,
                            REF_INT_MIN &_sycl_min,
@@ -416,9 +417,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   );
 
-  std::cout << "\tsum = " << sycl_sum.get() << std::endl;
-  std::cout << "\tmin = " << sycl_min.get() << std::endl;
-  std::cout << "\tmax = " << sycl_max.get() << std::endl;
+  std::cout << "\tsum = " << sycl_sum << std::endl;
+  std::cout << "\tmin = " << sycl_min << std::endl;
+  std::cout << "\tmax = " << sycl_max << std::endl;
   std::cout << "\tmin, loc = " << sycl_minloc.getVal() << " , "
                                << sycl_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << sycl_maxloc.getVal() << " , "

From b6e0e819242f9de25fe1fc05c068c42ef55e96be Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 13 Sep 2024 17:29:38 -0700
Subject: [PATCH 46/82] Remove need for T() in ValLoc.

---
 include/RAJA/pattern/params/params_base.hpp | 2 --
 include/RAJA/util/SoAPtr.hpp                | 2 +-
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index 313decc429..51f05a69a6 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -23,8 +23,6 @@ namespace expt
     RAJA_HOST_DEVICE constexpr bool operator<(const ValLoc& rhs) const { return val < rhs.val; }
     RAJA_HOST_DEVICE constexpr bool operator>(const ValLoc& rhs) const { return val > rhs.val; }
 
-    RAJA_HOST_DEVICE constexpr explicit operator T() const { return val; }
-
     RAJA_HOST_DEVICE constexpr value_type getVal() const {return val;}
     RAJA_HOST_DEVICE constexpr index_type getLoc() const {return loc;}
 
diff --git a/include/RAJA/util/SoAPtr.hpp b/include/RAJA/util/SoAPtr.hpp
index 717d7418ca..6adea65b80 100644
--- a/include/RAJA/util/SoAPtr.hpp
+++ b/include/RAJA/util/SoAPtr.hpp
@@ -230,7 +230,7 @@ class SoAPtr<RAJA::expt::ValLoc<T, IndexType>, mempool, accessor>
   }
   RAJA_HOST_DEVICE void set(size_t i, value_type val)
   {
-    accessor::set(mem, i, first_type(val));
+    accessor::set(mem, i, val.getVal());
     accessor::set(mem_idx, i, val.getLoc());
   }
 

From ea6bfcbda413c70c753e4d6dbaffa550415c8219 Mon Sep 17 00:00:00 2001
From: Jason Burmark <burmark1@llnl.gov>
Date: Mon, 16 Sep 2024 16:02:49 -0700
Subject: [PATCH 47/82] Add host device to math util

---
 include/RAJA/util/math.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/RAJA/util/math.hpp b/include/RAJA/util/math.hpp
index 66b0c9058c..99d7bc192e 100644
--- a/include/RAJA/util/math.hpp
+++ b/include/RAJA/util/math.hpp
@@ -59,7 +59,7 @@ constexpr T log2(T n) noexcept
 */
 template < typename T,
            std::enable_if_t<std::is_integral<T>::value>* = nullptr >
-RAJA_HOST_DEVICE
+RAJA_HOST_DEVICE RAJA_INLINE
 constexpr T next_pow2(T n) noexcept
 {
   --n;
@@ -81,7 +81,7 @@ constexpr T next_pow2(T n) noexcept
 */
 template < typename T,
            std::enable_if_t<std::is_integral<T>::value>* = nullptr >
-RAJA_HOST_DEVICE
+RAJA_HOST_DEVICE RAJA_INLINE
 constexpr T prev_pow2(T n) noexcept
 {
   if ( n < 0 ) return 0;
@@ -96,6 +96,7 @@ constexpr T prev_pow2(T n) noexcept
 */
 template < typename L, typename R,
            std::enable_if_t<std::is_integral<L>::value && std::is_integral<R>::value>* = nullptr >
+RAJA_HOST_DEVICE RAJA_INLINE
 constexpr auto power_of_2_mod(L lhs, R rhs) noexcept
 {
   return lhs & (rhs-R(1));

From ecd403648e3fa33eca943ba8d56526426f2f16a8 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Mon, 16 Sep 2024 19:23:54 -0700
Subject: [PATCH 48/82] Clean up interface and internals of ValOp.

---
 include/RAJA/pattern/params/params_base.hpp   | 32 +++++-----
 include/RAJA/pattern/params/reducer.hpp       | 10 +--
 include/RAJA/policy/cuda/params/reduce.hpp    | 45 -------------
 include/RAJA/policy/hip/params/reduce.hpp     | 39 ------------
 include/RAJA/policy/openmp/params/reduce.hpp  | 63 +------------------
 .../policy/openmp_target/params/reduce.hpp    |  6 +-
 .../RAJA/policy/sequential/params/reduce.hpp  |  6 +-
 include/RAJA/policy/sycl/params/reduce.hpp    |  6 +-
 .../test-forall-basic-expt-ReduceMaxLoc.hpp   | 13 ++++
 .../test-forall-basic-expt-ReduceMinLoc.hpp   | 13 ++++
 10 files changed, 57 insertions(+), 176 deletions(-)

diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index 51f05a69a6..a5b5e3266f 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -9,6 +9,7 @@ namespace expt
 
   template<typename T, typename IndexType = RAJA::Index_type>
   struct ValLoc {
+    public:
     using index_type = IndexType;
     using value_type = T;
 
@@ -16,10 +17,6 @@ namespace expt
     RAJA_HOST_DEVICE constexpr explicit ValLoc(value_type v) : val(v) {}
     RAJA_HOST_DEVICE constexpr ValLoc(value_type v, index_type l) : val(v), loc(l) {}
 
-    RAJA_HOST_DEVICE constexpr void min(value_type v, index_type l) { if (v < val) { val = v; loc = l; } }
-
-    RAJA_HOST_DEVICE constexpr void max(value_type v, index_type l) { if (v > val) { val = v; loc = l; } }
-
     RAJA_HOST_DEVICE constexpr bool operator<(const ValLoc& rhs) const { return val < rhs.val; }
     RAJA_HOST_DEVICE constexpr bool operator>(const ValLoc& rhs) const { return val > rhs.val; }
 
@@ -28,13 +25,13 @@ namespace expt
 
     RAJA_HOST_DEVICE void set(T inval, IndexType inindex) {val = inval; loc = inindex;}
 
-  //private:
     value_type val;
     index_type loc = -1;
   };
 
   template<typename T, template <typename, typename, typename> class Op>
   struct ValOp {
+    public:
     using value_type = T;
     using op_type = Op<T,T,T>;
 
@@ -64,15 +61,12 @@ namespace expt
     RAJA_HOST_DEVICE constexpr bool operator<(const ValOp& rhs) const { val < rhs.val; return *this; }
     RAJA_HOST_DEVICE constexpr bool operator>(const ValOp& rhs) const { val > rhs.val; return *this; }
 
-    RAJA_HOST_DEVICE constexpr value_type get() const {return val;}
-    RAJA_HOST_DEVICE void set(value_type inval) {val = inval;}
-
-  //private:
     value_type val = op_type::identity();
   };
 
   template<typename T, typename IndexType, template <typename, typename, typename> class Op>
   struct ValOp <ValLoc<T,IndexType>, Op> {
+    public:
     using index_type = IndexType;
     using value_type = ValLoc<T,index_type>;
     using op_type = Op<value_type,value_type,value_type>;
@@ -84,10 +78,12 @@ namespace expt
     RAJA_HOST_DEVICE constexpr explicit ValOp(valloc_value_type v) : val(v) {}
     RAJA_HOST_DEVICE constexpr ValOp(valloc_value_type v, valloc_index_type l) : val(v, l) {}
 
+    // Normal min and max for loc reducers.
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
-    RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
+    RAJA_HOST_DEVICE constexpr T min(T v) { if (v < val.val) { val.val = v; return val.val; } return v; }
+
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<value_type,value_type,value_type>>::value> * = nullptr>
-    RAJA_HOST_DEVICE constexpr ValOp & max(value_type v) { if (v > val) { val = v; } return *this; }
+    RAJA_HOST_DEVICE constexpr T max(T v) { if (v > val.val) { val.val = v; return val.val; } return v; }
 
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
     RAJA_HOST_DEVICE constexpr ValOp & minloc(valloc_value_type v, valloc_index_type l) { return min(value_type(v,l)); }
@@ -98,15 +94,15 @@ namespace expt
     RAJA_HOST_DEVICE constexpr bool operator<(const ValOp& rhs) const { return val < rhs.val; }
     RAJA_HOST_DEVICE constexpr bool operator>(const ValOp& rhs) const { return val > rhs.val; }
 
-    //RAJA_HOST_DEVICE constexpr value_type get() const {return val;}
-    //RAJA_HOST_DEVICE constexpr valloc_value_type getVal() const {return val.getVal();}
-    //RAJA_HOST_DEVICE constexpr valloc_index_type getLoc() const {return val.getLoc();}
+    value_type val = op_type::identity();
 
-    //RAJA_HOST_DEVICE void setVal(T inval) {val.val = inval;}
-    //RAJA_HOST_DEVICE void setLoc(index_type inindex) {val.loc = inindex;}
+    private:
+    // These are called by maxloc and minloc, and should not be available to the user.
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
 
-  //private:
-    value_type val = op_type::identity();
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<value_type,value_type,value_type>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & max(value_type v) { if (v > val) { val = v; } return *this; }
   };
 
   template<typename T, typename IndexType, template <typename, typename, typename> class Op>
diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 5ea9a2bfa3..89edfa1b36 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -61,20 +61,20 @@ namespace detail
     using value_type = T;
 
     RAJA_HOST_DEVICE Reducer() {}
-    RAJA_HOST_DEVICE Reducer(value_type *target_in) : target(target_in), val(VType{}){}
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : target(target_in), valop_m(VType{}){}
 
     value_type *target = nullptr;
-    VType val = VType{};
+    VType valop_m = VType{};
 
     template <typename U = VType, std::enable_if_t<std::is_same<U,ValOp<T,Op>>::value>* = nullptr>
     RAJA_HOST_DEVICE
     value_type &
-    getVal() { return val.val; }
+    getVal() { return valop_m.val; }
 
     template <typename U = VType, std::enable_if_t<std::is_same<U,ValOp<ValLoc<T,IndexType>,Op>>::value>* = nullptr>
     RAJA_HOST_DEVICE
     value_type &
-    getVal() { return val.val.val; }
+    getVal() { return valop_m.val.val; }
 
 #if defined(RAJA_CUDA_ACTIVE) || defined(RAJA_HIP_ACTIVE) || defined(RAJA_SYCL_ACTIVE)
     // Device related attributes.
@@ -84,7 +84,7 @@ namespace detail
 #endif
 
     using ARG_TUP_T = camp::tuple<VType*>;
-    RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&val); }
+    RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&valop_m); }
 
     using ARG_LIST_T = typename ARG_TUP_T::TList;
     static constexpr size_t num_lambda_args = camp::tuple_size<ARG_TUP_T>::value ;
diff --git a/include/RAJA/policy/cuda/params/reduce.hpp b/include/RAJA/policy/cuda/params/reduce.hpp
index eab401032e..fbb154f0b6 100644
--- a/include/RAJA/policy/cuda/params/reduce.hpp
+++ b/include/RAJA/policy/cuda/params/reduce.hpp
@@ -54,51 +54,6 @@ namespace detail {
     red.devicetarget = nullptr;
   }
 
-//  // Init
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-//  init(Reducer<OP, T, T>& red, RAJA::cuda::detail::cudaInfo& ci)
-//  {
-//    red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
-//    red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
-//    red.device_count = RAJA::cuda::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
-//  }
-//
-//  // Combine
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  RAJA_HOST_DEVICE
-//  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-//  combine(Reducer<OP, T, T>& red)
-//  //combine(Reducer<OP, T>& red)
-//  {
-//    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter>(red);
-//    //RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter>(red.devicetarget,
-//    //                                                                        red.val,
-//    //                                                                        red.device_mem,
-//    //                                                                        red.device_count);
-//  }
-//
-//  // Resolve
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  //template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-//  resolve(Reducer<OP, T, T>& red, RAJA::cuda::detail::cudaInfo& ci)
-//  //resolve(Reducer<OP, T>& red, RAJA::cuda::detail::cudaInfo& ci)
-//  {
-//    // complete reduction
-//    ci.res.wait();
-//    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
-//    printf( "RCC DANGER\n" );
-//
-//    // free memory
-//    RAJA::cuda::device_zeroed_mempool_type::getInstance().free(red.device_count);
-//    red.device_count = nullptr;
-//    red.device_mem.deallocate();
-//    RAJA::cuda::pinned_mempool_type::getInstance().free(red.devicetarget);
-//    red.devicetarget = nullptr;
-//  }
-
-
 } //  namespace detail
 } //  namespace expt
 } //  namespace RAJA
diff --git a/include/RAJA/policy/hip/params/reduce.hpp b/include/RAJA/policy/hip/params/reduce.hpp
index 0d20d5afb7..639df8b505 100644
--- a/include/RAJA/policy/hip/params/reduce.hpp
+++ b/include/RAJA/policy/hip/params/reduce.hpp
@@ -51,45 +51,6 @@ namespace detail {
     red.devicetarget = nullptr;
   }
 
-//  // Init
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  //template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-//  init(Reducer<OP, T, T>& red, RAJA::hip::detail::hipInfo& hi)
-//  {
-//    red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
-//    red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
-//    red.device_count = RAJA::hip::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
-//  }
-//
-//  // Combine
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  //template<typename EXEC_POL, typename OP, typename T>
-//  RAJA_HOST_DEVICE
-//  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-//  combine(Reducer<OP, T, T>& red)
-//  {
-//    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter>(red);
-//  }
-//
-//  // Resolve
-//  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T>
-//  //template<typename EXEC_POL, typename OP, typename T>
-//  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-//  resolve(Reducer<OP, T, T>& red, RAJA::hip::detail::hipInfo& hi)
-//  {
-//    // complete reduction
-//    hi.res.wait();
-//    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
-//
-//    // free memory
-//    RAJA::hip::device_zeroed_mempool_type::getInstance().free(red.device_count);
-//    red.device_count = nullptr;
-//    red.device_mem.deallocate();
-//    RAJA::hip::pinned_mempool_type::getInstance().free(red.devicetarget);
-//    red.devicetarget = nullptr;
-//  }
-
 } //  namespace detail
 } //  namespace expt
 } //  namespace RAJA
diff --git a/include/RAJA/policy/openmp/params/reduce.hpp b/include/RAJA/policy/openmp/params/reduce.hpp
index 7a0d95f9fc..4eb63d7bbd 100644
--- a/include/RAJA/policy/openmp/params/reduce.hpp
+++ b/include/RAJA/policy/openmp/params/reduce.hpp
@@ -9,82 +9,25 @@ namespace detail {
 
 #if defined(RAJA_ENABLE_OPENMP)
 
-/*
-  // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
-           std::enable_if_t<std::is_same<T, RAJA::expt::ValLoc<int,RAJA::Index_type>>::value>* = nullptr >
-  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red) {
-    red.val.val = OP<T,T,T>::identity();
-  }
-
-  // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
-           std::enable_if_t<std::is_same<T, RAJA::expt::ValLoc<int,RAJA::Index_type>>::value>* = nullptr >
-  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
-  }
-
-  // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
-           std::enable_if_t<std::is_same<T, RAJA::expt::ValLoc<int,RAJA::Index_type>>::value>* = nullptr >
-  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red) {
-  //resolve(Reducer<OP, T, ValOp<ValLoc<T,U>,OP>>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
-  }
-
-  // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
-           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value>* = nullptr >
-  //template<typename EXEC_POL, typename OP, typename T>
-  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red) {
-  //init(Reducer<OP, T>& red) {
-    red.val.val = OP<T,T,T>::identity();
-  }
-
-  // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
-           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value>* = nullptr >
-  //template<typename EXEC_POL, typename OP, typename T>
-  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-  //combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
-  }
-
-  // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType,
-           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value>* = nullptr >
-  //template<typename EXEC_POL, typename OP, typename T>
-  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red) {
-  //resolve(Reducer<OP, T>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
-  }
-*/
-
   // Init
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
   init(Reducer<OP, T, VType>& red) {
-    red.val.val = OP<T,T,T>::identity();
+    red.valop_m.val = OP<T,T,T>::identity();
   }
 
   // Combine
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
   combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
+    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
   resolve(Reducer<OP, T, VType>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
+    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
   }
 
 #endif
diff --git a/include/RAJA/policy/openmp_target/params/reduce.hpp b/include/RAJA/policy/openmp_target/params/reduce.hpp
index f7b26a6b83..9c8bb9a2d3 100644
--- a/include/RAJA/policy/openmp_target/params/reduce.hpp
+++ b/include/RAJA/policy/openmp_target/params/reduce.hpp
@@ -13,21 +13,21 @@ namespace detail {
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
   init(Reducer<OP, T, VType>& red) {
-    red.val.val = OP<T,T,T>::identity();
+    red.valop_m.val = OP<T,T,T>::identity();
   }
 
   // Combine
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
   combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
+    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
   resolve(Reducer<OP, T, VType>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
+    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
   }
 
 #endif
diff --git a/include/RAJA/policy/sequential/params/reduce.hpp b/include/RAJA/policy/sequential/params/reduce.hpp
index fef39eef9d..1e04c8aaa4 100644
--- a/include/RAJA/policy/sequential/params/reduce.hpp
+++ b/include/RAJA/policy/sequential/params/reduce.hpp
@@ -11,21 +11,21 @@ namespace detail {
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
   init(Reducer<OP, T, VType>& red) {
-    red.val.val = OP<T,T,T>::identity();
+    red.valop_m.val = OP<T,T,T>::identity();
   }
 
   // Combine
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
   combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
+    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
   resolve(Reducer<OP, T, VType>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
+    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
   }
 
 } //  namespace detail
diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index 64f95a5a02..4e4d50df3b 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -13,19 +13,19 @@ namespace detail {
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   init(Reducer<OP, T, VType>& red) {
-    red.val.val = OP<T,T,T>::identity();
+    red.valop_m.val = OP<T,T,T>::identity();
   }
   // Combine
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-    out.val.val = OP<T,T,T>{}(out.val.val, in.val.val);
+    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
   }
   // Resolve
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   resolve(Reducer<OP, T, VType>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.val.val);
+    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
   }
 
 #endif
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
index 80be078094..ca8b61a32d 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
@@ -97,7 +97,20 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
+
+  max.set(max_init, maxloc_init);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), max_init);
+  ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), maxloc_init);
  
+  factor = 4;
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
+      m.max( working_array[idx] * factor);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
+  ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), maxloc_init);
+
 
   deallocateForallTestData<DATA_TYPE>(working_res,
                                       working_array,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
index be580df1c9..3af65e2383 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
@@ -96,6 +96,19 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
+
+  min.set(min_init, minloc_init);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), min_init);
+  ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), minloc_init);
+
+  factor = 4;
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
+      m.min( working_array[idx] * factor);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
+  ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), minloc_init);
    
 
   deallocateForallTestData<DATA_TYPE>(working_res,

From 41b531a1741598220628131041a27dce04c11a9d Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Mon, 16 Sep 2024 19:44:49 -0700
Subject: [PATCH 49/82] Cleanup.

---
 include/RAJA/policy/cuda/reduce.hpp | 1 -
 include/RAJA/policy/hip/reduce.hpp  | 1 -
 2 files changed, 2 deletions(-)

diff --git a/include/RAJA/policy/cuda/reduce.hpp b/include/RAJA/policy/cuda/reduce.hpp
index 670051f4e3..87130ddfe8 100644
--- a/include/RAJA/policy/cuda/reduce.hpp
+++ b/include/RAJA/policy/cuda/reduce.hpp
@@ -201,7 +201,6 @@ RAJA_DEVICE RAJA_INLINE int grid_reduce_last_block(T& val,
 namespace expt {
 
 template <typename ThreadIterationGetter, template <typename, typename, typename> class Combiner, typename T>
-//template <typename ThreadIterationGetter, typename Combiner, typename T>
 RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 {
   const int numThreads = ThreadIterationGetter::size();
diff --git a/include/RAJA/policy/hip/reduce.hpp b/include/RAJA/policy/hip/reduce.hpp
index 843bdee09e..567712f29a 100644
--- a/include/RAJA/policy/hip/reduce.hpp
+++ b/include/RAJA/policy/hip/reduce.hpp
@@ -195,7 +195,6 @@ RAJA_DEVICE RAJA_INLINE int grid_reduce_last_block(T& val,
 namespace expt {
 
 template <typename ThreadIterationGetter, template <typename, typename, typename> class Combiner, typename T>
-//template <typename ThreadIterationGetter, typename Combiner, typename T>
 RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 {
   const int numThreads = ThreadIterationGetter::size();

From f54bcc13c7ff42ea08c4720300e32d739c4991c4 Mon Sep 17 00:00:00 2001
From: Arturo Vargas <vargas45@llnl.gov>
Date: Tue, 17 Sep 2024 13:22:49 -0700
Subject: [PATCH 50/82] move raja_view perf test to benchmark folder

---
 benchmark/CMakeLists.txt        |   4 +
 benchmark/raja_view_blur.cpp    | 170 ++++++++++++++++++++++++++++++++
 examples/CMakeLists.txt         |   4 -
 examples/raja_view_slowdown.cpp | 145 ---------------------------
 4 files changed, 174 insertions(+), 149 deletions(-)
 create mode 100644 benchmark/raja_view_blur.cpp
 delete mode 100644 examples/raja_view_slowdown.cpp

diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 8ddeba454d..e4ca0e1809 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -18,3 +18,7 @@ raja_add_benchmark(
 raja_add_benchmark(
   NAME ltimes
   SOURCES ltimes.cpp)
+
+raja_add_bench_mark(
+  NAME raja_view_blur
+  SOURCES raja_view_blur.cpp)
diff --git a/benchmark/raja_view_blur.cpp b/benchmark/raja_view_blur.cpp
new file mode 100644
index 0000000000..c3db04b2dd
--- /dev/null
+++ b/benchmark/raja_view_blur.cpp
@@ -0,0 +1,170 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+// Copyright (c) 2016-24, Lawrence Livermore National Security, LLC
+// and RAJA project contributors. See the RAJA/LICENSE file for details.
+//
+// SPDX-License-Identifier: (BSD-3-Clause)
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+
+#include <RAJA/RAJA.hpp>
+#include "RAJA/util/Timer.hpp"
+#include <iostream>
+
+/*
+ * RAJA view performance test
+ * Kernel performs a 2D Gaussian blur
+ *
+ */
+
+#if defined(RAJA_ENABLE_HIP)
+using device_pol = RAJA::hip_exec<256>;
+using device_resources = RAJA::resource::Hip;
+
+using kernel_pol = RAJA::KernelPolicy<
+  RAJA::statement::HipKernelFixed<256,
+    RAJA::statement::For<1, RAJA::hip_global_size_y_direct<16>,
+      RAJA::statement::For<0, RAJA::hip_global_size_x_direct<16>,
+         RAJA::statement::Lambda<0>
+      >
+    >
+   >
+  >;
+#elif defined(RAJA_ENABLE_CUDA)
+using device_pol = RAJA::cuda_exec<256>;
+using device_resources = RAJA::resources::Cuda;
+
+using kernel_pol = RAJA::KernelPolicy<
+  RAJA::statement::CudaKernelFixed<256,
+    RAJA::statement::For<1, RAJA::cuda_global_size_y_direct<16>,
+      RAJA::statement::For<0, RAJA::cuda_global_size_x_direct<16>,
+         RAJA::statement::Lambda<0>
+      >
+    >
+   >
+  >;
+#else
+using host_pol = RAJA::seq_exec;
+using device_resources = RAJA::resources::Host;
+#endif
+
+using host_resources = RAJA::resources::Host;
+
+int main(int RAJA_UNUSED_ARG(argc), char **RAJA_UNUSED_ARG(argv[]))
+{
+
+  const int N = 10000;
+  const int K = 17;
+  
+  device_resources def_device_res{device_resources::get_default()};
+  host_resources   def_host_res{host_resources::get_default()};
+  
+  auto timer = RAJA::Timer();
+  
+  //launch to intialize the stream
+  RAJA::forall<device_pol>
+    (RAJA::RangeSegment(0,1), [=] RAJA_DEVICE (int i) {
+      printf(" \n");
+  });
+
+  int * array      = def_host_res.allocate<int>(N * N);
+  int * array_copy = def_host_res.allocate<int>(N * N);
+  
+  //big array, or image
+  for (int i = 0; i < N * N; ++i) {
+    array[i] = 1;
+    array_copy[i] = 1;
+  }
+
+  //small array that acts as the blur
+  //int* kernel = new int[K * K];
+  int * kernel  = def_host_res.allocate<int>(K * K);
+  for (int i = 0; i < K * K; ++i) {
+    kernel[i] = 2;
+  }
+
+  // copying to gpu
+  int* d_array      = def_device_res.allocate<int>(N * N);
+  int* d_array_copy = def_device_res.allocate<int>(N * N);
+  int* d_kernel     = def_device_res.allocate<int>(K * K);
+
+  def_device_res.memcpy(d_array, array, N * N * sizeof(int));
+  def_device_res.memcpy(d_array_copy, array_copy, N * N * sizeof(int));
+  def_device_res.memcpy(d_kernel, kernel, K * K * sizeof(int));
+
+  constexpr int DIM = 2;
+  RAJA::View<int, RAJA::Layout<DIM, int, 1>> array_view(d_array, N, N);
+  RAJA::View<int, RAJA::Layout<DIM, int, 1>> array_view_copy(d_array_copy, N, N);
+  RAJA::View<int, RAJA::Layout<DIM, int, 1>> kernel_view(d_kernel, K, K);
+
+  RAJA::RangeSegment range_i(0, N);
+  RAJA::RangeSegment range_j(0, N);
+
+  timer.start();
+
+  RAJA::kernel<kernel_pol>
+    (RAJA::make_tuple(range_i, range_j),
+     [=] RAJA_DEVICE (int i, int j) {
+      int sum = 0;
+
+      //looping through the "blur"
+      for (int m = 0; m < K; ++m) {
+	for (int n = 0; n < K; ++n) {
+	  int x = i + m;
+	  int y = j + n;
+
+	  // adding the "blur" to the "image" wherever the blur is located on the image
+	  if (x < N && y < N) {
+	    sum += kernel_view(m, n) * array_view(x, y);
+	  }
+	}
+      }
+
+      array_view(i, j) += sum;
+    }
+   );
+
+  timer.stop();
+
+  std::cout<<"Elapsed time with RAJA view : "<<timer.elapsed()<<std::endl;
+
+
+ timer.reset();
+ timer.start();
+ 
+  RAJA::kernel<kernel_pol>
+    (RAJA::make_tuple(range_i, range_j),
+     [=] RAJA_DEVICE (int i, int j) {
+      int sum = 0;
+
+      // looping through the "blur"
+      for (int m = 0; m < K; ++m) {
+	for (int n = 0; n < K; ++n) {
+	  int x = i + m;
+	  int y = j + n;
+
+	  // adding the "blur" to the "image" wherever the blur is located on the image
+	  if (x < N && y < N) {
+	    sum += d_kernel[m * K + n] * d_array_copy[x * N + y];
+	  }
+	}
+      }
+
+      d_array_copy[i * N + j] += sum;
+    }
+  );
+  timer.stop();
+
+  std::cout<<"Elapsed time with NO RAJA view : "<<timer.elapsed()<<std::endl;
+
+  def_device_res.memcpy(array, d_array, N * N * sizeof(int));
+  def_device_res.memcpy(array_copy, d_array_copy, N * N * sizeof(int));
+
+  def_device_res.deallocate(d_array);
+  def_device_res.deallocate(d_array_copy);
+  def_device_res.deallocate(d_kernel);
+    
+  def_host_res.deallocate(array);
+  def_host_res.deallocate(array_copy);
+  def_host_res.deallocate(kernel);
+  
+  return 0;
+}
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index fd1aed62ba..4dfd2fbc10 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -3,10 +3,6 @@
 # SPDX-License-Identifier: (BSD-3-Clause)
 ###############################################################################
 
-raja_add_executable(
-  NAME raja_view_slowdown
-  SOURCES raja_view_slowdown.cpp)
-
 raja_add_executable(
   NAME tut_launch_basic
   SOURCES tut_launch_basic.cpp)
diff --git a/examples/raja_view_slowdown.cpp b/examples/raja_view_slowdown.cpp
deleted file mode 100644
index 7b7dc8def3..0000000000
--- a/examples/raja_view_slowdown.cpp
+++ /dev/null
@@ -1,145 +0,0 @@
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
-// Copyright (c) 2016-24, Lawrence Livermore National Security, LLC
-// and RAJA project contributors. See the RAJA/LICENSE file for details.
-//
-// SPDX-License-Identifier: (BSD-3-Clause)
-//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
-
-#include <RAJA/RAJA.hpp>
-#include "RAJA/util/Timer.hpp"
-#include <iostream>
-
-int main() {
-
-  const int N = 10000;
-  const int K = 17;
-
-  auto timer = RAJA::Timer();
-
-  //launch to intialize the stream
-  RAJA::forall<RAJA::cuda_exec<256>>
-    (RAJA::RangeSegment(0,1), [=] __device__ (int i) {
-    printf("launch kernel\n");
-  });
-
-
-  int* array = new int[N * N];
-  int* array_copy = new int[N * N];
-
-  //big array, or image
-  for (int i = 0; i < N * N; ++i) {
-    array[i] = 1;
-    array_copy[i] = 1;
-  }
-
-  //small array that acts as the blur
-  int* kernel = new int[K * K];
-  for (int i = 0; i < K * K; ++i) {
-    kernel[i] = 2;
-  }
-
-  // copying to gpu
-  int* d_array;
-  int* d_array_copy;
-  int* d_kernel;
-  cudaMalloc((void**)&d_array, N * N * sizeof(int));
-  cudaMalloc((void**)&d_array_copy, N * N * sizeof(int));
-  cudaMalloc((void**)&d_kernel, K * K * sizeof(int));
-  cudaMemcpy(d_array, array, N * N * sizeof(int), cudaMemcpyHostToDevice);
-  cudaMemcpy(d_array_copy, array_copy, N * N * sizeof(int), cudaMemcpyHostToDevice);
-  cudaMemcpy(d_kernel, kernel, K * K * sizeof(int), cudaMemcpyHostToDevice);
-
-
-  constexpr int DIM = 2;
-  RAJA::View<int, RAJA::Layout<DIM, int, 1>> array_view(d_array, N, N);
-  RAJA::View<int, RAJA::Layout<DIM, int, 1>> array_view_copy(d_array_copy, N, N);
-  RAJA::View<int, RAJA::Layout<DIM, int, 1>> kernel_view(d_kernel, K, K);
-
-
-  using EXEC_POL5 = RAJA::KernelPolicy<
-    RAJA::statement::CudaKernelFixed<256,
-      RAJA::statement::For<1, RAJA::cuda_global_size_y_direct<16>,
-        RAJA::statement::For<0, RAJA::cuda_global_size_x_direct<16>,
-	  RAJA::statement::Lambda<0>
-	  >
-       >
-     >
-    >;
-
-  RAJA::RangeSegment range_i(0, N);
-  RAJA::RangeSegment range_j(0, N);
-
-
-timer.start();
-
-  RAJA::kernel<EXEC_POL5>
-    (RAJA::make_tuple(range_i, range_j),
-     [=] RAJA_DEVICE (int i, int j) {
-      int sum = 0;
-
-      //looping through the "blur"
-      for (int m = 0; m < K; ++m) {
-	for (int n = 0; n < K; ++n) {
-	  int x = i + m;
-	  int y = j + n;
-
-	  // adding the "blur" to the "image" wherever the blur is located on the image
-	  if (x < N && y < N) {
-	    sum += kernel_view(m, n) * array_view(x, y);
-	  }
-	}
-      }
-
-      array_view(i, j) += sum;
-    }
-   );
-
-timer.stop();
-
-std::cout<<"Elapsed time with RAJA view : "<<timer.elapsed()<<std::endl;
-
-
-timer.reset();
-timer.start();
-
-  RAJA::kernel<EXEC_POL5>
-    (RAJA::make_tuple(range_i, range_j),
-     [=] RAJA_DEVICE (int i, int j) {
-      int sum = 0;
-
-      // looping through the "blur"
-      for (int m = 0; m < K; ++m) {
-	for (int n = 0; n < K; ++n) {
-	  int x = i + m;
-	  int y = j + n;
-
-	  // adding the "blur" to the "image" wherever the blur is located on the image
-	  if (x < N && y < N) {
-	    sum += d_kernel[m * K + n] * d_array_copy[x * N + y];
-	  }
-	}
-      }
-
-      d_array_copy[i * N + j] += sum;
-    }
-  );
-
-timer.stop();
-std::cout<<"Elapsed time with NO RAJA view : "<<timer.elapsed()<<std::endl;
-
-  // copy from gpu to cpu
-  cudaMemcpy(array, d_array, N * N * sizeof(int), cudaMemcpyDeviceToHost);
-  cudaMemcpy(array_copy, d_array_copy, N * N * sizeof(int), cudaMemcpyDeviceToHost);
-
-
-  cudaFree(d_array);
-  cudaFree(d_array_copy);
-  cudaFree(d_kernel);
-
-
-  delete[] array;
-  delete[] array_copy;
-  delete[] kernel;
-
-  return 0;
-}

From ac4da44a837c451a5e8017fd2c00ef15d112152f Mon Sep 17 00:00:00 2001
From: Arturo Vargas <vargas45@llnl.gov>
Date: Tue, 17 Sep 2024 14:04:24 -0700
Subject: [PATCH 51/82] add links to the raja portability suite tutorial

---
 README.md      | 6 ++++--
 docs/index.rst | 3 ++-
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 27146b1a6c..c9eb238ab0 100644
--- a/README.md
+++ b/README.md
@@ -71,8 +71,8 @@ More details about RAJA configuration options are located in the RAJA User Guide
 We also maintain a [**RAJA Template Project**](https://github.com/LLNL/RAJA-project-template) that shows how to use RAJA in a CMake project, either as a Git
 submodule or as an installed library.
 
-User Documentation
--------------------
+User Documentation and Tutorials
+--------------------------------
 
 The RAJA User Guide is the best place to start learning about RAJA and how to
 use it.
@@ -81,6 +81,8 @@ The most recent version of the User Guide (RAJA develop branch): https://raja.re
 
 To access docs for other RAJA released versions: https://readthedocs.org/projects/raja/
 
+We maintain a repository for the RAJA portaility suite tutorial material: https://github.com/LLNL/raja-suite-tutorial
+
 To cite RAJA, please use the following references:
 
 * RAJA Performance Portability Layer. https://github.com/LLNL/RAJA
diff --git a/docs/index.rst b/docs/index.rst
index 450bab4447..e558afe1da 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -121,7 +121,8 @@ RAJA User Documentation
 =======================
 
   * :doc:`RAJA User Guide <sphinx/user_guide/index>`
-  * `RAJA Tutorials Repo <https://github.com/LLNL/RAJA-tutorials>`_
+  * `RAJA Portability Suite Tutorial Repo <https://github.com/LLNL/raja-suite-tutorial>`_
+  * `Archived RAJA Tutorials Repo <https://github.com/LLNL/RAJA-tutorials>`_
   * `Source Documentation <doxygen/html/index.html>`_
 
 ============================

From dd45e66e2256df6be87bf607a71cdd51b9f724a1 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Wed, 18 Sep 2024 12:44:47 -0700
Subject: [PATCH 52/82] Min and max functions taking a ValLoc. Only allowed
 within a lambda via ValOp.

---
 include/RAJA/pattern/params/params_base.hpp      | 13 ++-----------
 .../test-forall-basic-expt-ReduceMaxLoc.hpp      | 16 +++++++---------
 .../test-forall-basic-expt-ReduceMinLoc.hpp      | 14 ++++++--------
 3 files changed, 15 insertions(+), 28 deletions(-)

diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index a5b5e3266f..309b06a2c4 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -78,12 +78,11 @@ namespace expt
     RAJA_HOST_DEVICE constexpr explicit ValOp(valloc_value_type v) : val(v) {}
     RAJA_HOST_DEVICE constexpr ValOp(valloc_value_type v, valloc_index_type l) : val(v, l) {}
 
-    // Normal min and max for loc reducers.
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
-    RAJA_HOST_DEVICE constexpr T min(T v) { if (v < val.val) { val.val = v; return val.val; } return v; }
+    RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
 
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<value_type,value_type,value_type>>::value> * = nullptr>
-    RAJA_HOST_DEVICE constexpr T max(T v) { if (v > val.val) { val.val = v; return val.val; } return v; }
+    RAJA_HOST_DEVICE constexpr ValOp & max(value_type v) { if (v > val) { val = v; } return *this; }
 
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
     RAJA_HOST_DEVICE constexpr ValOp & minloc(valloc_value_type v, valloc_index_type l) { return min(value_type(v,l)); }
@@ -95,14 +94,6 @@ namespace expt
     RAJA_HOST_DEVICE constexpr bool operator>(const ValOp& rhs) const { return val > rhs.val; }
 
     value_type val = op_type::identity();
-
-    private:
-    // These are called by maxloc and minloc, and should not be available to the user.
-    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
-    RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
-
-    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<value_type,value_type,value_type>>::value> * = nullptr>
-    RAJA_HOST_DEVICE constexpr ValOp & max(value_type v) { if (v > val) { val = v; } return *this; }
   };
 
   template<typename T, typename IndexType, template <typename, typename, typename> class Op>
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
index ca8b61a32d..7992919fca 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
@@ -98,18 +98,16 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
 
-  max.set(max_init, maxloc_init);
-  ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), max_init);
-  ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), maxloc_init);
- 
-  factor = 4;
+  VL_TYPE max2(max_init, maxloc_init);
+
   RAJA::forall<EXEC_POLICY>(seg,
     RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
-      m.max( working_array[idx] * factor);
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE RAJA_UNUSED_ARG(&m), VL_LAMBDA_TYPE &m2) {
+      m2.max( max );
   });
-  ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
-  ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), maxloc_init);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max2.getVal()), static_cast<DATA_TYPE>(max.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(max2.getLoc()), static_cast<IDX_TYPE>(max.getLoc()));
 
 
   deallocateForallTestData<DATA_TYPE>(working_res,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
index 3af65e2383..322065745d 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
@@ -97,18 +97,16 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
 
-  min.set(min_init, minloc_init);
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), min_init);
-  ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), minloc_init);
+  VL_TYPE min2(min_init, minloc_init);
 
-  factor = 4;
   RAJA::forall<EXEC_POLICY>(seg,
     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
-      m.min( working_array[idx] * factor);
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE RAJA_UNUSED_ARG(&m), VL_LAMBDA_TYPE &m2) {
+      m2.min( min );
   });
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
-  ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), minloc_init);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min2.getVal()), static_cast<DATA_TYPE>(min.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(min2.getLoc()), static_cast<IDX_TYPE>(min.getLoc()));
    
 
   deallocateForallTestData<DATA_TYPE>(working_res,

From 1b81cb9b74e6fd2824912e8bec5104e41e14cdb9 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Wed, 18 Sep 2024 17:21:47 -0700
Subject: [PATCH 53/82] Add alternative reduction capability.

---
 include/RAJA/pattern/params/reducer.hpp       | 16 +++++-
 include/RAJA/policy/cuda/params/reduce.hpp    | 55 +++++++++++++++++--
 include/RAJA/policy/hip/params/reduce.hpp     | 54 ++++++++++++++++--
 include/RAJA/policy/openmp/params/reduce.hpp  | 35 ++++++++++--
 .../policy/openmp_target/params/reduce.hpp    | 23 ++++++++
 .../RAJA/policy/sequential/params/reduce.hpp  | 36 ++++++++++--
 include/RAJA/policy/sycl/params/reduce.hpp    | 37 +++++++++++--
 7 files changed, 223 insertions(+), 33 deletions(-)

diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 89edfa1b36..0da3c67125 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -55,16 +55,19 @@ namespace detail
   // Basic Reducer
   //
   //
-  template <template <typename, typename, typename> class Op, typename T, typename VType, typename IndexType = RAJA::Index_type>
+  template <template <typename, typename, typename> class Op, typename T, typename VType, typename DataType = T, typename IndexType = RAJA::Index_type, bool passthru = false>
   struct Reducer : public ForallParamBase {
     using op = Op<T,T,T>;
     using value_type = T;
 
     RAJA_HOST_DEVICE Reducer() {}
-    RAJA_HOST_DEVICE Reducer(value_type *target_in) : target(target_in), valop_m(VType{}){}
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : valop_m(VType{}), target(target_in){}
+    RAJA_HOST_DEVICE Reducer(DataType *data_in, IndexType *index_in) : valop_m(VType(*data_in, *index_in)), target(&valop_m.val), passthruval(data_in), passthruindex(index_in) {}
 
-    value_type *target = nullptr;
     VType valop_m = VType{};
+    value_type *target = nullptr;
+    DataType *passthruval = nullptr;
+    IndexType *passthruindex = nullptr; 
 
     template <typename U = VType, std::enable_if_t<std::is_same<U,ValOp<T,Op>>::value>* = nullptr>
     RAJA_HOST_DEVICE
@@ -98,6 +101,13 @@ auto constexpr Reduce(T *target)
   return detail::Reducer<Op, T, VType>(target);
 }
 
+template <template <typename, typename, typename> class Op, typename T, typename IndexType = RAJA::Index_type, bool passingthru = true,
+          std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value> * = nullptr>
+auto constexpr ReduceLoc(T *target, IndexType *index)
+{
+  return detail::Reducer<Op, ValLoc<T, IndexType>, ValLocOp<T, IndexType, Op>, T, IndexType, passingthru>(target, index);
+}
+
 } // namespace expt
 
 
diff --git a/include/RAJA/policy/cuda/params/reduce.hpp b/include/RAJA/policy/cuda/params/reduce.hpp
index fbb154f0b6..e8dde1087d 100644
--- a/include/RAJA/policy/cuda/params/reduce.hpp
+++ b/include/RAJA/policy/cuda/params/reduce.hpp
@@ -15,9 +15,9 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
+  init(Reducer<OP, T, VType, D, I, true>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
     red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
@@ -25,10 +25,10 @@ namespace detail {
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& red)
+  combine(Reducer<OP, T, VType, D, I, true>& red)
   {
     RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP, T>(red.devicetarget,
                                                                             red.getVal(),
@@ -37,9 +37,52 @@ namespace detail {
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
+  resolve(Reducer<OP, T, VType, D, I, true>& red, RAJA::cuda::detail::cudaInfo& ci)
+  {
+    // complete reduction
+    ci.res.wait();
+
+    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
+
+    *red.passthruval = red.target->val;
+    *red.passthruindex = red.target->loc;
+
+    // free memory
+    RAJA::cuda::device_zeroed_mempool_type::getInstance().free(red.device_count);
+    red.device_count = nullptr;
+    red.device_mem.deallocate();
+    RAJA::cuda::pinned_mempool_type::getInstance().free(red.devicetarget);
+    red.devicetarget = nullptr;
+  }
+
+  // Init
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
+  init(Reducer<OP, T, VType, D, I, false>& red, RAJA::cuda::detail::cudaInfo& ci)
+  {
+    red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
+    red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
+    red.device_count = RAJA::cuda::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
+  }
+
+  // Combine
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  RAJA_HOST_DEVICE
+  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
+  combine(Reducer<OP, T, VType, D, I, false>& red)
+  {
+    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP, T>(red.devicetarget,
+                                                                            red.getVal(),
+                                                                            red.device_mem,
+                                                                            red.device_count);
+  }
+
+  // Resolve
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
+  resolve(Reducer<OP, T, VType, D, I, false>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
     // complete reduction
     ci.res.wait();
diff --git a/include/RAJA/policy/hip/params/reduce.hpp b/include/RAJA/policy/hip/params/reduce.hpp
index 639df8b505..687d170982 100644
--- a/include/RAJA/policy/hip/params/reduce.hpp
+++ b/include/RAJA/policy/hip/params/reduce.hpp
@@ -13,9 +13,9 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red, RAJA::hip::detail::hipInfo& hi)
+  init(Reducer<OP, T, VType, D, I, true>& red, RAJA::hip::detail::hipInfo& hi)
   {
     red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
@@ -23,10 +23,10 @@ namespace detail {
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& red)
+  combine(Reducer<OP, T, VType, D, I, true>& red)
   {
     RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP,T>( red.devicetarget,
                                                                             red.getVal(),
@@ -35,9 +35,51 @@ namespace detail {
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red, RAJA::hip::detail::hipInfo& hi)
+  resolve(Reducer<OP, T, VType, D, I, true>& red, RAJA::hip::detail::hipInfo& hi)
+  {
+    // complete reduction
+    hi.res.wait();
+    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
+
+    *red.passthruval = red.target->val;
+    *red.passthruindex = red.target->loc;
+
+    // free memory
+    RAJA::hip::device_zeroed_mempool_type::getInstance().free(red.device_count);
+    red.device_count = nullptr;
+    red.device_mem.deallocate();
+    RAJA::hip::pinned_mempool_type::getInstance().free(red.devicetarget);
+    red.devicetarget = nullptr;
+  }
+
+  // Init
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
+  init(Reducer<OP, T, VType, D, I, false>& red, RAJA::hip::detail::hipInfo& hi)
+  {
+    red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
+    red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
+    red.device_count = RAJA::hip::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
+  }
+
+  // Combine
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  RAJA_HOST_DEVICE
+  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
+  combine(Reducer<OP, T, VType, D, I, false>& red)
+  {
+    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP,T>( red.devicetarget,
+                                                                            red.getVal(),
+                                                                            red.device_mem,
+                                                                            red.device_count);
+  }
+
+  // Resolve
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
+  resolve(Reducer<OP, T, VType, D, I, false>& red, RAJA::hip::detail::hipInfo& hi)
   {
     // complete reduction
     hi.res.wait();
diff --git a/include/RAJA/policy/openmp/params/reduce.hpp b/include/RAJA/policy/openmp/params/reduce.hpp
index 4eb63d7bbd..a139f2c031 100644
--- a/include/RAJA/policy/openmp/params/reduce.hpp
+++ b/include/RAJA/policy/openmp/params/reduce.hpp
@@ -10,23 +10,46 @@ namespace detail {
 #if defined(RAJA_ENABLE_OPENMP)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red) {
+  init(Reducer<OP, T, VType, D, I, true>& red) {
     red.valop_m.val = OP<T,T,T>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+  combine(Reducer<OP, T, VType, D, I, true>& out, const Reducer<OP, T, VType, D, I, true>& in) {
     out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red) {
+  resolve(Reducer<OP, T, VType, D, I, true>& red) {
+    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
+    *red.passthruval = red.valop_m.val.val;
+    *red.passthruindex = red.valop_m.val.loc;
+  }
+
+  // Init
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+  init(Reducer<OP, T, VType, D, I, false>& red) {
+    red.valop_m.val = OP<T,T,T>::identity();
+  }
+
+  // Combine
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+  combine(Reducer<OP, T, VType, D, I, false>& out, const Reducer<OP, T, VType, D, I, false>& in) {
+    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
+  }
+
+  // Resolve
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
+  resolve(Reducer<OP, T, VType, D, I, false>& red) {
     *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
   }
 
diff --git a/include/RAJA/policy/openmp_target/params/reduce.hpp b/include/RAJA/policy/openmp_target/params/reduce.hpp
index 9c8bb9a2d3..18c2f72e06 100644
--- a/include/RAJA/policy/openmp_target/params/reduce.hpp
+++ b/include/RAJA/policy/openmp_target/params/reduce.hpp
@@ -9,6 +9,29 @@ namespace detail {
 
 #if defined(RAJA_ENABLE_TARGET_OPENMP)
 
+  // Init
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
+  init(Reducer<OP, T, VType, D, I, true>& red) {
+    red.valop_m.val = OP<T,T,T>::identity();
+  }
+
+  // Combine
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
+  combine(Reducer<OP, T, VType, D, I, true>& out, const Reducer<OP, T, VType, D, I, true>& in) {
+    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
+  }
+
+  // Resolve
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
+  resolve(Reducer<OP, T, VType, D, I, true>& red) {
+    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
+    *red.passthruval = red.valop_m.val.val;
+    *red.passthruindex = red.valop_m.val.loc;
+  }
+
   // Init
   template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
diff --git a/include/RAJA/policy/sequential/params/reduce.hpp b/include/RAJA/policy/sequential/params/reduce.hpp
index 1e04c8aaa4..7a0b447a83 100644
--- a/include/RAJA/policy/sequential/params/reduce.hpp
+++ b/include/RAJA/policy/sequential/params/reduce.hpp
@@ -8,23 +8,47 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  init(Reducer<OP, T, VType>& red) {
+  init(Reducer<OP, T, VType, D, I, true>& red) {
     red.valop_m.val = OP<T,T,T>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+  combine(Reducer<OP, T, VType, D, I, true>& out, const Reducer<OP, T, VType, D, I, true>& in) {
     out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  resolve(Reducer<OP, T, VType>& red) {
+  resolve(Reducer<OP, T, VType, D, I, true>& red) {
+    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
+    *red.passthruval = red.valop_m.val.val;
+    *red.passthruindex = red.valop_m.val.loc;
+  }
+
+
+  // Init
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
+  init(Reducer<OP, T, VType, D, I, false>& red) {
+    red.valop_m.val = OP<T,T,T>::identity();
+  }
+
+  // Combine
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
+  combine(Reducer<OP, T, VType, D, I, false>& out, const Reducer<OP, T, VType, D, I, false>& in) {
+    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
+  }
+
+  // Resolve
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
+  resolve(Reducer<OP, T, VType, D, I, false>& red) {
     *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
   }
 
diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index 4e4d50df3b..e2ce443d5b 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -10,21 +10,46 @@ namespace detail {
 #if defined(RAJA_ENABLE_SYCL)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red) {
+  init(Reducer<OP, T, VType, D, I, true>& red) {
     red.valop_m.val = OP<T,T,T>::identity();
   }
+
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+  combine(Reducer<OP, T, VType, D, I, true>& out, const Reducer<OP, T, VType, D, I, true>& in) {
     out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
   }
+
+  // Resolve
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
+  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
+  resolve(Reducer<OP, T, VType, D, I, true>& red) {
+    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
+    *red.passthruval = red.valop_m.val.val;
+    *red.passthruindex = red.valop_m.val.loc;
+  }
+
+  // Init
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
+  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
+  init(Reducer<OP, T, VType, D, I, false>& red) {
+    red.valop_m.val = OP<T,T,T>::identity();
+  }
+
+  // Combine
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
+  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
+  combine(Reducer<OP, T, VType, D, I, false>& out, const Reducer<OP, T, VType, D, I, false>& in) {
+    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
+  }
+
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red) {
+  resolve(Reducer<OP, T, VType, D, I, false>& red) {
     *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
   }
 

From 81ee96365d29442e85fe3e029e2c7881e547d39b Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Wed, 18 Sep 2024 17:22:24 -0700
Subject: [PATCH 54/82] Tests for alternative reduction capability.

---
 examples/forall-param-reductions.cpp          | 96 +++++++++++++++++--
 .../test-forall-basic-expt-ReduceMaxLoc.hpp   | 18 ++++
 .../test-forall-basic-expt-ReduceMinLoc.hpp   | 18 ++++
 3 files changed, 126 insertions(+), 6 deletions(-)

diff --git a/examples/forall-param-reductions.cpp b/examples/forall-param-reductions.cpp
index 5dfcb6411f..904bd71008 100644
--- a/examples/forall-param-reductions.cpp
+++ b/examples/forall-param-reductions.cpp
@@ -129,14 +129,21 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT seq_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT seq_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int seq_min2 = std::numeric_limits<int>::max();
+  int seq_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type seq_minloc2(-1);
+  RAJA::Index_type seq_maxloc2(-1);
+
   RAJA::forall<EXEC_POL1>(host_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&seq_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&seq_min2, &seq_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&seq_max2, &seq_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce Seq Kernel"),
-    [=](int i, REF_INT_SUM &_seq_sum, REF_INT_MIN &_seq_min, REF_INT_MAX &_seq_max, REFLOC_INT_MIN &_seq_minloc, REFLOC_INT_MAX &_seq_maxloc) {
+    [=](int i, REF_INT_SUM &_seq_sum, REF_INT_MIN &_seq_min, REF_INT_MAX &_seq_max, REFLOC_INT_MIN &_seq_minloc, REFLOC_INT_MAX &_seq_maxloc, REFLOC_INT_MIN &_seq_minloc2, REFLOC_INT_MAX &_seq_maxloc2) {
       _seq_sum += a[i];
 
       _seq_min.min(a[i]);
@@ -144,6 +151,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
       _seq_minloc.minloc(a[i], i);
       _seq_maxloc.maxloc(a[i], i);
+
+      _seq_minloc2.minloc(a[i], i);
+      _seq_maxloc2.maxloc(a[i], i);
     }
   );
 
@@ -154,6 +164,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << seq_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << seq_maxloc.getVal() << " , "
                                << seq_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << seq_min2 << " , "
+                                  << seq_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << seq_max2 << " , "
+                                  << seq_maxloc2 << std::endl;
   // _reductions_raja_seq_end
 
 
@@ -172,14 +186,21 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT omp_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT omp_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int omp_min2 = std::numeric_limits<int>::max();
+  int omp_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type omp_minloc2(-1);
+  RAJA::Index_type omp_maxloc2(-1);
+
   RAJA::forall<EXEC_POL2>(host_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&omp_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&omp_min2, &omp_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&omp_max2, &omp_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce OpenMP Kernel"),
-    [=](int i, REF_INT_SUM &_omp_sum, REF_INT_MIN &_omp_min, REF_INT_MAX &_omp_max, REFLOC_INT_MIN &_omp_minloc, REFLOC_INT_MAX &_omp_maxloc) {
+    [=](int i, REF_INT_SUM &_omp_sum, REF_INT_MIN &_omp_min, REF_INT_MAX &_omp_max, REFLOC_INT_MIN &_omp_minloc, REFLOC_INT_MAX &_omp_maxloc, REFLOC_INT_MIN &_omp_minloc2, REFLOC_INT_MAX &_omp_maxloc2) {
       _omp_sum += a[i];
 
       _omp_min.min(a[i]);
@@ -187,6 +208,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
       _omp_minloc.minloc(a[i], i);
       _omp_maxloc.maxloc(a[i], i);
+
+      _omp_minloc2.minloc(a[i], i);
+      _omp_maxloc2.maxloc(a[i], i);
     }
   );
 
@@ -197,6 +221,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << omp_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << omp_maxloc.getVal() << " , "
                                << omp_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << omp_min2 << " , "
+                                  << omp_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << omp_max2 << " , "
+                                  << omp_maxloc2 << std::endl;
 
 #endif
 
@@ -217,14 +245,21 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT omp_t_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT omp_t_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int omp_t_min2 = std::numeric_limits<int>::max();
+  int omp_t_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type omp_t_minloc2(-1);
+  RAJA::Index_type omp_t_maxloc2(-1);
+
   RAJA::forall<EXEC_POL3>(omp_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&omp_t_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_t_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_t_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_t_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_t_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&omp_t_min2, &omp_t_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&omp_t_max2, &omp_t_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce Target OpenMP Kernel"),
-    [=](int i, REF_INT_SUM &_omp_t_sum, REF_INT_MIN &_omp_t_min, REF_INT_MAX &_omp_t_max, REFLOC_INT_MIN &_omp_t_minloc, REFLOC_INT_MAX &_omp_t_maxloc) {
+    [=](int i, REF_INT_SUM &_omp_t_sum, REF_INT_MIN &_omp_t_min, REF_INT_MAX &_omp_t_max, REFLOC_INT_MIN &_omp_t_minloc, REFLOC_INT_MAX &_omp_t_maxloc, REFLOC_INT_MIN &_omp_t_minloc2, REFLOC_INT_MAX &_omp_t_maxloc2) {
       _omp_t_sum += a[i];
 
       _omp_t_min.min(a[i]);
@@ -232,6 +267,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
       _omp_t_minloc.minloc(a[i], i);
       _omp_t_maxloc.maxloc(a[i], i);
+
+      _omp_t_minloc2.minloc(a[i], i);
+      _omp_t_maxloc2.maxloc(a[i], i);
     }
   );
 
@@ -242,6 +280,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << omp_t_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << omp_t_maxloc.getVal() << " , "
                                << omp_t_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << omp_t_min2 << " , "
+                                  << omp_t_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << omp_t_max2 << " , "
+                                  << omp_t_maxloc2 << std::endl;
 
 #endif
 
@@ -266,14 +308,21 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT cuda_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT cuda_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int cuda_min2 = std::numeric_limits<int>::max();
+  int cuda_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type cuda_minloc2(-1);
+  RAJA::Index_type cuda_maxloc2(-1);
+
   RAJA::forall<EXEC_POL3>(cuda_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&cuda_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&cuda_min2, &cuda_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&cuda_max2, &cuda_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce CUDA Kernel"),
-    [=] RAJA_DEVICE (int i, REF_INT_SUM &_cuda_sum, REF_INT_MIN &_cuda_min, REF_INT_MAX &_cuda_max, REFLOC_INT_MIN &_cuda_minloc, REFLOC_INT_MAX &_cuda_maxloc) {
+    [=] RAJA_DEVICE (int i, REF_INT_SUM &_cuda_sum, REF_INT_MIN &_cuda_min, REF_INT_MAX &_cuda_max, REFLOC_INT_MIN &_cuda_minloc, REFLOC_INT_MAX &_cuda_maxloc, REFLOC_INT_MIN &_cuda_minloc2, REFLOC_INT_MAX &_cuda_maxloc2) {
       _cuda_sum += d_a[i];
 
       _cuda_min.min(d_a[i]);
@@ -281,6 +330,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
       _cuda_minloc.minloc(a[i], i);
       _cuda_maxloc.maxloc(a[i], i);
+
+      _cuda_minloc2.minloc(a[i], i);
+      _cuda_maxloc2.maxloc(a[i], i);
     }
   );
 
@@ -291,6 +343,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << cuda_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << cuda_maxloc.getVal() << " , "
                                << cuda_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << cuda_min2 << " , "
+                                  << cuda_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << cuda_max2 << " , "
+                                  << cuda_maxloc2 << std::endl;
   cuda_res.deallocate(d_a);
 #endif
 
@@ -314,14 +370,21 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT hip_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT hip_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int hip_min2 = std::numeric_limits<int>::max();
+  int hip_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type hip_minloc2(-1);
+  RAJA::Index_type hip_maxloc2(-1);
+
   RAJA::forall<EXEC_POL3>(hip_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&hip_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&hip_min2, &hip_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&hip_max2, &hip_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce HIP Kernel"),
-    [=] RAJA_DEVICE (int i, REF_INT_SUM &_hip_sum, REF_INT_MIN &_hip_min, REF_INT_MAX &_hip_max, REFLOC_INT_MIN &_hip_minloc, REFLOC_INT_MAX &_hip_maxloc) {
+    [=] RAJA_DEVICE (int i, REF_INT_SUM &_hip_sum, REF_INT_MIN &_hip_min, REF_INT_MAX &_hip_max, REFLOC_INT_MIN &_hip_minloc, REFLOC_INT_MAX &_hip_maxloc, REFLOC_INT_MIN &_hip_minloc2, REFLOC_INT_MAX &_hip_maxloc2) {
       _hip_sum += d_a[i];
 
       _hip_min.min(d_a[i]);
@@ -329,6 +392,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
       _hip_minloc.minloc(d_a[i], i);
       _hip_maxloc.maxloc(d_a[i], i);
+
+      _hip_minloc2.minloc(d_a[i], i);
+      _hip_maxloc2.maxloc(d_a[i], i);
     }
   );
 
@@ -339,6 +405,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << hip_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << hip_maxloc.getVal() << " , "
                                << hip_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << hip_min2 << " , "
+                                  << hip_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << hip_max2 << " , "
+                                  << hip_maxloc2 << std::endl;
 
   hip_res.deallocate(d_a);
 #endif
@@ -363,14 +433,21 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT sycl_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT sycl_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int sycl_min2 = std::numeric_limits<int>::max();
+  int sycl_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type sycl_minloc2(-1);
+  RAJA::Index_type sycl_maxloc2(-1);
+
   RAJA::forall<EXEC_POL3>(sycl_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&sycl_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&sycl_min2, &sycl_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&sycl_max2, &sycl_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce SYCL Kernel"),
-    [=] RAJA_DEVICE (int i, REF_INT_SUM &_sycl_sum, REF_INT_MIN &_sycl_min, REF_INT_MAX &_sycl_max, REFLOC_INT_MIN &_sycl_minloc, REFLOC_INT_MAX &_sycl_maxloc) {
+    [=] RAJA_DEVICE (int i, REF_INT_SUM &_sycl_sum, REF_INT_MIN &_sycl_min, REF_INT_MAX &_sycl_max, REFLOC_INT_MIN &_sycl_minloc, REFLOC_INT_MAX &_sycl_maxloc, REFLOC_INT_MIN &_sycl_minloc2, REFLOC_INT_MAX &_sycl_maxloc2) {
       _sycl_sum += d_a[i];
 
       _sycl_min.min(d_a[i]);
@@ -378,6 +455,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
       _sycl_minloc.minloc(d_a[i], i);
       _sycl_maxloc.maxloc(d_a[i], i);
+
+      _sycl_minloc2.minloc(d_a[i], i);
+      _sycl_maxloc2.maxloc(d_a[i], i);
     }
   );
 
@@ -388,6 +468,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << sycl_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << sycl_maxloc.getVal() << " , "
                                << sycl_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << sycl_min2 << " , "
+                                  << sycl_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << sycl_max2 << " , "
+                                  << sycl_maxloc2 << std::endl;
 
   sycl_res.deallocate(d_a);
 #endif
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
index 7992919fca..231ac3e98f 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
@@ -109,6 +109,24 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   ASSERT_EQ(static_cast<DATA_TYPE>(max2.getVal()), static_cast<DATA_TYPE>(max.getVal()));
   ASSERT_EQ(static_cast<IDX_TYPE>(max2.getLoc()), static_cast<IDX_TYPE>(max.getLoc()));
 
+  DATA_TYPE s_max = max_init;
+  DATA_TYPE s_max2 = max_init;
+  IDX_TYPE s_maxloc = maxloc_init;
+  IDX_TYPE s_maxloc2 = maxloc_init;
+
+  factor = 4;
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max, &s_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max2, &s_maxloc2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m, VL_LAMBDA_TYPE &m2) {
+      m.maxloc( working_array[idx] * factor, idx);
+      m2.max(max2);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_max), ref_max * factor);
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_maxloc), ref_maxloc);
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_max2), static_cast<DATA_TYPE>(max2.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_maxloc2), static_cast<IDX_TYPE>(max2.getLoc()));
+
 
   deallocateForallTestData<DATA_TYPE>(working_res,
                                       working_array,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
index 322065745d..6268c0dbd5 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
@@ -107,6 +107,24 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(min2.getVal()), static_cast<DATA_TYPE>(min.getVal()));
   ASSERT_EQ(static_cast<IDX_TYPE>(min2.getLoc()), static_cast<IDX_TYPE>(min.getLoc()));
+
+  DATA_TYPE s_min = min_init;
+  DATA_TYPE s_min2 = min_init;
+  IDX_TYPE s_minloc = minloc_init;
+  IDX_TYPE s_minloc2 = minloc_init;
+
+  factor = 4;
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min, &s_minloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min2, &s_minloc2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m, VL_LAMBDA_TYPE &m2) {
+      m.minloc( working_array[idx] * factor, idx);
+      m2.min(min2);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_min), ref_min * factor);
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_minloc), ref_minloc);
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_min2), static_cast<DATA_TYPE>(min2.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_minloc2), static_cast<IDX_TYPE>(min2.getLoc()));
    
 
   deallocateForallTestData<DATA_TYPE>(working_res,

From 1e13b59f370b2ac5d3c77fce244dcd68f53d5ab8 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 19 Sep 2024 09:53:14 -0700
Subject: [PATCH 55/82] Fix SYCL typo.

---
 include/RAJA/policy/sycl/params/reduce.hpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index e2ce443d5b..b76917bac5 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -10,21 +10,21 @@ namespace detail {
 #if defined(RAJA_ENABLE_SYCL)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   init(Reducer<OP, T, VType, D, I, true>& red) {
     red.valop_m.val = OP<T,T,T>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   combine(Reducer<OP, T, VType, D, I, true>& out, const Reducer<OP, T, VType, D, I, true>& in) {
     out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   resolve(Reducer<OP, T, VType, D, I, true>& red) {
     *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
@@ -33,21 +33,21 @@ namespace detail {
   }
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   init(Reducer<OP, T, VType, D, I, false>& red) {
     red.valop_m.val = OP<T,T,T>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   combine(Reducer<OP, T, VType, D, I, false>& out, const Reducer<OP, T, VType, D, I, false>& in) {
     out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   resolve(Reducer<OP, T, VType, D, I, false>& red) {
     *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);

From fea0b8c5fbd866af3866e2bf3569eef0d1f9d973 Mon Sep 17 00:00:00 2001
From: Arturo Vargas <vargas45@llnl.gov>
Date: Thu, 19 Sep 2024 11:11:23 -0700
Subject: [PATCH 56/82] add guard

---
 benchmark/CMakeLists.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 8ddeba454d..15d919c566 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -11,9 +11,11 @@ if (RAJA_ENABLE_CUDA)
     SOURCES host-device-lambda-benchmark.cpp)
 endif()
 
+if (RAJA_ENABLE_DESUL)
 raja_add_benchmark(
   NAME benchmark-atomic
   SOURCES benchmark-atomic.cpp)
+endif()
 
 raja_add_benchmark(
   NAME ltimes

From a414e121086f3af7fc3bf464eb8ff049dd26b6f4 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 19 Sep 2024 11:16:59 -0700
Subject: [PATCH 57/82] Update various constructors in Val.

---
 include/RAJA/pattern/params/params_base.hpp | 33 ++++++++++++++-------
 include/RAJA/pattern/params/reducer.hpp     |  7 ++++-
 2 files changed, 28 insertions(+), 12 deletions(-)

diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index 309b06a2c4..36759bd4fb 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -9,19 +9,23 @@ namespace expt
 
   template<typename T, typename IndexType = RAJA::Index_type>
   struct ValLoc {
-    public:
     using index_type = IndexType;
     using value_type = T;
 
-    RAJA_HOST_DEVICE constexpr ValLoc() {}
+    RAJA_HOST_DEVICE constexpr ValLoc() = default;
     RAJA_HOST_DEVICE constexpr explicit ValLoc(value_type v) : val(v) {}
-    RAJA_HOST_DEVICE constexpr ValLoc(value_type v, index_type l) : val(v), loc(l) {}
+    RAJA_HOST_DEVICE constexpr explicit ValLoc(value_type v, index_type l) : val(v), loc(l) {}
+
+    RAJA_HOST_DEVICE constexpr ValLoc(ValLoc const &) = default;
+    RAJA_HOST_DEVICE constexpr ValLoc(ValLoc &&) = default;
+    RAJA_HOST_DEVICE ValLoc& operator=(ValLoc const &) = default;
+    RAJA_HOST_DEVICE ValLoc& operator=(ValLoc &&) = default;
 
     RAJA_HOST_DEVICE constexpr bool operator<(const ValLoc& rhs) const { return val < rhs.val; }
     RAJA_HOST_DEVICE constexpr bool operator>(const ValLoc& rhs) const { return val > rhs.val; }
 
-    RAJA_HOST_DEVICE constexpr value_type getVal() const {return val;}
-    RAJA_HOST_DEVICE constexpr index_type getLoc() const {return loc;}
+    RAJA_HOST_DEVICE constexpr const value_type& getVal() const {return val;}
+    RAJA_HOST_DEVICE constexpr const index_type& getLoc() const {return loc;}
 
     RAJA_HOST_DEVICE void set(T inval, IndexType inindex) {val = inval; loc = inindex;}
 
@@ -31,13 +35,17 @@ namespace expt
 
   template<typename T, template <typename, typename, typename> class Op>
   struct ValOp {
-    public:
     using value_type = T;
     using op_type = Op<T,T,T>;
 
-    RAJA_HOST_DEVICE constexpr ValOp() {}
+    RAJA_HOST_DEVICE constexpr ValOp() = default;
     RAJA_HOST_DEVICE constexpr explicit ValOp(value_type v) : val(v) {}
 
+    RAJA_HOST_DEVICE constexpr ValOp(ValOp const &) = default;
+    RAJA_HOST_DEVICE constexpr ValOp(ValOp &&) = default;
+    RAJA_HOST_DEVICE ValOp& operator=(ValOp const &) = default;
+    RAJA_HOST_DEVICE ValOp& operator=(ValOp &&) = default;
+
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<T,T,T>>::value> * = nullptr>
     RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<T,T,T>>::value> * = nullptr>
@@ -66,17 +74,20 @@ namespace expt
 
   template<typename T, typename IndexType, template <typename, typename, typename> class Op>
   struct ValOp <ValLoc<T,IndexType>, Op> {
-    public:
     using index_type = IndexType;
     using value_type = ValLoc<T,index_type>;
     using op_type = Op<value_type,value_type,value_type>;
     using valloc_value_type = typename value_type::value_type;
     using valloc_index_type = typename value_type::index_type;
 
-    RAJA_HOST_DEVICE constexpr ValOp() {}
+    RAJA_HOST_DEVICE constexpr ValOp() = default;
     RAJA_HOST_DEVICE constexpr explicit ValOp(value_type v) : val(v) {}
-    RAJA_HOST_DEVICE constexpr explicit ValOp(valloc_value_type v) : val(v) {}
-    RAJA_HOST_DEVICE constexpr ValOp(valloc_value_type v, valloc_index_type l) : val(v, l) {}
+    RAJA_HOST_DEVICE constexpr explicit ValOp(valloc_value_type v, valloc_index_type l) : val(v, l) {}
+
+    RAJA_HOST_DEVICE constexpr ValOp(ValOp const &) = default;
+    RAJA_HOST_DEVICE constexpr ValOp(ValOp &&) = default;
+    RAJA_HOST_DEVICE ValOp& operator=(ValOp const &) = default;
+    RAJA_HOST_DEVICE ValOp& operator=(ValOp &&) = default;
 
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
     RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 0da3c67125..3bf68898dd 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -60,10 +60,15 @@ namespace detail
     using op = Op<T,T,T>;
     using value_type = T;
 
-    RAJA_HOST_DEVICE Reducer() {}
+    RAJA_HOST_DEVICE Reducer() = default;
     RAJA_HOST_DEVICE Reducer(value_type *target_in) : valop_m(VType{}), target(target_in){}
     RAJA_HOST_DEVICE Reducer(DataType *data_in, IndexType *index_in) : valop_m(VType(*data_in, *index_in)), target(&valop_m.val), passthruval(data_in), passthruindex(index_in) {}
 
+    RAJA_HOST_DEVICE constexpr Reducer(Reducer const &) = default;
+    RAJA_HOST_DEVICE constexpr Reducer(Reducer &&) = default;
+    RAJA_HOST_DEVICE Reducer& operator=(Reducer const &) = default;
+    RAJA_HOST_DEVICE Reducer& operator=(Reducer &&) = default;
+
     VType valop_m = VType{};
     value_type *target = nullptr;
     DataType *passthruval = nullptr;

From 6cd997a06ff1d2eef745a8e68acb10d97f4b000d Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 19 Sep 2024 14:32:09 -0700
Subject: [PATCH 58/82] Update examples with ValOp.

---
 examples/forall-param-reductions.cpp |  66 +++++++++++---
 examples/launch-param-reductions.cpp | 128 ++++++++++++++++++++-------
 2 files changed, 148 insertions(+), 46 deletions(-)

diff --git a/examples/forall-param-reductions.cpp b/examples/forall-param-reductions.cpp
index 904bd71008..88c526cfe7 100644
--- a/examples/forall-param-reductions.cpp
+++ b/examples/forall-param-reductions.cpp
@@ -107,14 +107,14 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   using VALLOC_INT = RAJA::expt::ValLoc<int, RAJA::Index_type>;
 
 //
-// Define ValLoc Safe Type
+// Define ValOp Types
 //
 
-  using REF_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
-  using REF_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
-  using REF_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
-  using REFLOC_INT_MIN = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::minimum>;
-  using REFLOC_INT_MAX = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::maximum>;
+  using VALOP_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
+  using VALOP_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
+  using VALOP_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
+  using VALOPLOC_INT_MIN = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::minimum>;
+  using VALOPLOC_INT_MAX = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::maximum>;
 
 //----------------------------------------------------------------------------//
 
@@ -143,7 +143,14 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&seq_min2, &seq_minloc2),
     RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&seq_max2, &seq_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce Seq Kernel"),
-    [=](int i, REF_INT_SUM &_seq_sum, REF_INT_MIN &_seq_min, REF_INT_MAX &_seq_max, REFLOC_INT_MIN &_seq_minloc, REFLOC_INT_MAX &_seq_maxloc, REFLOC_INT_MIN &_seq_minloc2, REFLOC_INT_MAX &_seq_maxloc2) {
+    [=](int i,
+        VALOP_INT_SUM &_seq_sum,
+        VALOP_INT_MIN &_seq_min,
+        VALOP_INT_MAX &_seq_max,
+        VALOPLOC_INT_MIN &_seq_minloc,
+        VALOPLOC_INT_MAX &_seq_maxloc,
+        VALOPLOC_INT_MIN &_seq_minloc2,
+        VALOPLOC_INT_MAX &_seq_maxloc2) {
       _seq_sum += a[i];
 
       _seq_min.min(a[i]);
@@ -200,7 +207,14 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&omp_min2, &omp_minloc2),
     RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&omp_max2, &omp_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce OpenMP Kernel"),
-    [=](int i, REF_INT_SUM &_omp_sum, REF_INT_MIN &_omp_min, REF_INT_MAX &_omp_max, REFLOC_INT_MIN &_omp_minloc, REFLOC_INT_MAX &_omp_maxloc, REFLOC_INT_MIN &_omp_minloc2, REFLOC_INT_MAX &_omp_maxloc2) {
+    [=](int i,
+        VALOP_INT_SUM &_omp_sum,
+        VALOP_INT_MIN &_omp_min,
+        VALOP_INT_MAX &_omp_max,
+        VALOPLOC_INT_MIN &_omp_minloc,
+        VALOPLOC_INT_MAX &_omp_maxloc,
+        VALOPLOC_INT_MIN &_omp_minloc2,
+        VALOPLOC_INT_MAX &_omp_maxloc2) {
       _omp_sum += a[i];
 
       _omp_min.min(a[i]);
@@ -259,7 +273,14 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&omp_t_min2, &omp_t_minloc2),
     RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&omp_t_max2, &omp_t_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce Target OpenMP Kernel"),
-    [=](int i, REF_INT_SUM &_omp_t_sum, REF_INT_MIN &_omp_t_min, REF_INT_MAX &_omp_t_max, REFLOC_INT_MIN &_omp_t_minloc, REFLOC_INT_MAX &_omp_t_maxloc, REFLOC_INT_MIN &_omp_t_minloc2, REFLOC_INT_MAX &_omp_t_maxloc2) {
+    [=](int i,
+				VALOP_INT_SUM &_omp_t_sum,
+				VALOP_INT_MIN &_omp_t_min,
+				VALOP_INT_MAX &_omp_t_max,
+				VALOPLOC_INT_MIN &_omp_t_minloc,
+				VALOPLOC_INT_MAX &_omp_t_maxloc,
+				VALOPLOC_INT_MIN &_omp_t_minloc2,
+				VALOPLOC_INT_MAX &_omp_t_maxloc2) {
       _omp_t_sum += a[i];
 
       _omp_t_min.min(a[i]);
@@ -322,7 +343,14 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&cuda_min2, &cuda_minloc2),
     RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&cuda_max2, &cuda_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce CUDA Kernel"),
-    [=] RAJA_DEVICE (int i, REF_INT_SUM &_cuda_sum, REF_INT_MIN &_cuda_min, REF_INT_MAX &_cuda_max, REFLOC_INT_MIN &_cuda_minloc, REFLOC_INT_MAX &_cuda_maxloc, REFLOC_INT_MIN &_cuda_minloc2, REFLOC_INT_MAX &_cuda_maxloc2) {
+    [=] RAJA_DEVICE ( int i,
+                      VALOP_INT_SUM &_cuda_sum,
+                      VALOP_INT_MIN &_cuda_min,
+                      VALOP_INT_MAX &_cuda_max,
+                      VALOPLOC_INT_MIN &_cuda_minloc,
+                      VALOPLOC_INT_MAX &_cuda_maxloc,
+                      VALOPLOC_INT_MIN &_cuda_minloc2,
+                      VALOPLOC_INT_MAX &_cuda_maxloc2) {
       _cuda_sum += d_a[i];
 
       _cuda_min.min(d_a[i]);
@@ -384,7 +412,14 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&hip_min2, &hip_minloc2),
     RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&hip_max2, &hip_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce HIP Kernel"),
-    [=] RAJA_DEVICE (int i, REF_INT_SUM &_hip_sum, REF_INT_MIN &_hip_min, REF_INT_MAX &_hip_max, REFLOC_INT_MIN &_hip_minloc, REFLOC_INT_MAX &_hip_maxloc, REFLOC_INT_MIN &_hip_minloc2, REFLOC_INT_MAX &_hip_maxloc2) {
+    [=] RAJA_DEVICE ( int i,
+                      VALOP_INT_SUM &_hip_sum,
+                      VALOP_INT_MIN &_hip_min,
+                      VALOP_INT_MAX &_hip_max,
+                      VALOPLOC_INT_MIN &_hip_minloc,
+                      VALOPLOC_INT_MAX &_hip_maxloc,
+                      VALOPLOC_INT_MIN &_hip_minloc2,
+                      VALOPLOC_INT_MAX &_hip_maxloc2) {
       _hip_sum += d_a[i];
 
       _hip_min.min(d_a[i]);
@@ -447,7 +482,14 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&sycl_min2, &sycl_minloc2),
     RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&sycl_max2, &sycl_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce SYCL Kernel"),
-    [=] RAJA_DEVICE (int i, REF_INT_SUM &_sycl_sum, REF_INT_MIN &_sycl_min, REF_INT_MAX &_sycl_max, REFLOC_INT_MIN &_sycl_minloc, REFLOC_INT_MAX &_sycl_maxloc, REFLOC_INT_MIN &_sycl_minloc2, REFLOC_INT_MAX &_sycl_maxloc2) {
+    [=] RAJA_DEVICE ( int i,
+				              VALOP_INT_SUM &_sycl_sum,
+				              VALOP_INT_MIN &_sycl_min,
+				              VALOP_INT_MAX &_sycl_max,
+				              VALOPLOC_INT_MIN &_sycl_minloc,
+				              VALOPLOC_INT_MAX &_sycl_maxloc,
+				              VALOPLOC_INT_MIN &_sycl_minloc2,
+				              VALOPLOC_INT_MAX &_sycl_maxloc2) {
       _sycl_sum += d_a[i];
 
       _sycl_min.min(d_a[i]);
diff --git a/examples/launch-param-reductions.cpp b/examples/launch-param-reductions.cpp
index 176d34cc24..5bec907c33 100644
--- a/examples/launch-param-reductions.cpp
+++ b/examples/launch-param-reductions.cpp
@@ -121,11 +121,16 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
   using VALLOC_INT = RAJA::expt::ValLoc<int>;
 
-  using REF_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
-  using REF_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
-  using REF_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
-  using REFLOC_INT_MIN = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::minimum>;
-  using REFLOC_INT_MAX = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::maximum>;
+//
+// Define ValOp Types
+//
+
+  using VALOP_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
+  using VALOP_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
+  using VALOP_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
+  using VALOPLOC_INT_MIN = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::minimum>;
+  using VALOPLOC_INT_MAX = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::maximum>;
+
 //----------------------------------------------------------------------------//
 
   std::cout << "\n Running RAJA sequential reductions...\n";
@@ -140,6 +145,11 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT seq_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT seq_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int seq_min2 = std::numeric_limits<int>::max();
+  int seq_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type seq_minloc2(-1);
+  RAJA::Index_type seq_maxloc2(-1);
+
   RAJA::launch<LAUNCH_POL1>
     (host_res, RAJA::LaunchParams(), "SeqReductionKernel",
     RAJA::expt::Reduce<RAJA::operators::plus   >(&seq_sum),
@@ -147,12 +157,16 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_maxloc),
-     [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           REF_INT_SUM &_seq_sum,
-                           REF_INT_MIN &_seq_min,
-                           REF_INT_MAX &_seq_max,
-                           REFLOC_INT_MIN &_seq_minloc,
-                           REFLOC_INT_MAX &_seq_maxloc) {
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&seq_min2, &seq_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&seq_max2, &seq_maxloc2),
+     [=] RAJA_HOST_DEVICE ( RAJA::LaunchContext ctx,
+                            VALOP_INT_SUM &_seq_sum,
+                            VALOP_INT_MIN &_seq_min,
+                            VALOP_INT_MAX &_seq_max,
+                            VALOPLOC_INT_MIN &_seq_minloc,
+                            VALOPLOC_INT_MAX &_seq_maxloc,
+                            VALOPLOC_INT_MIN &_seq_minloc2,
+                            VALOPLOC_INT_MAX &_seq_maxloc2) {
 
       RAJA::loop<LOOP_POL1>(ctx, arange, [&] (int i) {
 
@@ -163,9 +177,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
           _seq_minloc.minloc(a[i], i);
           _seq_maxloc.maxloc(a[i], i);
-          // Note : RAJA::expt::ValLoc<T> objects provide min() and max() methods
-          //        that are equivalent to the assignments with RAJA_MIN and RAJA_MAX
-          //        above.
+
+          _seq_minloc2.minloc(a[i], i);
+          _seq_maxloc2.maxloc(a[i], i);
         }
       );
 
@@ -198,6 +212,11 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT omp_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT omp_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int omp_min2 = std::numeric_limits<int>::max();
+  int omp_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type omp_minloc2(-1);
+  RAJA::Index_type omp_maxloc2(-1);
+
   RAJA::launch<LAUNCH_POL2>
     (host_res, RAJA::LaunchParams(), "OmpReductionKernel",
     RAJA::expt::Reduce<RAJA::operators::plus   >(&omp_sum),
@@ -205,12 +224,16 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&omp_min2, &omp_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&omp_max2, &omp_maxloc2),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           REF_INT_SUM &_omp_sum,
-                           REF_INT_MIN &_omp_min,
-                           REF_INT_MAX &_omp_max,
-                           REFLOC_INT_MIN &_omp_minloc,
-                           REFLOC_INT_MAX &_omp_maxloc) {
+                           VALOP_INT_SUM &_omp_sum,
+                           VALOP_INT_MIN &_omp_min,
+                           VALOP_INT_MAX &_omp_max,
+                           VALOPLOC_INT_MIN &_omp_minloc,
+                           VALOPLOC_INT_MAX &_omp_maxloc,
+                           VALOPLOC_INT_MIN &_omp_minloc2,
+                           VALOPLOC_INT_MAX &_omp_maxloc2) {
 
       RAJA::loop<LOOP_POL2>(ctx, arange, [&] (int i) {
 
@@ -221,6 +244,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 
           _omp_minloc.minloc(a[i], i);
           _omp_maxloc.maxloc(a[i], i);
+
+          _omp_minloc2.minloc(a[i], i);
+          _omp_maxloc2.maxloc(a[i], i);
         }
       );
 
@@ -258,6 +284,11 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT cuda_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT cuda_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int cuda_min2 = std::numeric_limits<int>::max();
+  int cuda_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type cuda_minloc2(-1);
+  RAJA::Index_type cuda_maxloc2(-1);
+
   RAJA::launch<LAUNCH_POL3>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(CUDA_BLOCK_SIZE)),
      "CUDAReductionKernel",
@@ -266,12 +297,16 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&cuda_min2, &cuda_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&cuda_max2, &cuda_maxloc2),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           REF_INT_SUM &_cuda_sum,
-                           REF_INT_MIN &_cuda_min,
-                           REF_INT_MAX &_cuda_max,
-                           REFLOC_INT_MIN &_cuda_minloc,
-                           REFLOC_INT_MAX &_cuda_maxloc) {
+                           VALOP_INT_SUM &_cuda_sum,
+                           VALOP_INT_MIN &_cuda_min,
+                           VALOP_INT_MAX &_cuda_max,
+                           VALOPLOC_INT_MIN &_cuda_minloc,
+                           VALOPLOC_INT_MAX &_cuda_maxloc,
+                           VALOPLOC_INT_MIN &_cuda_minloc2,
+                           VALOPLOC_INT_MAX &_cuda_maxloc2) {
 
 
       RAJA::loop<LOOP_POL3>(ctx, arange, [&] (int i) {
@@ -284,6 +319,9 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
           _cuda_minloc.minloc(a[i], i);
           _cuda_maxloc.maxloc(a[i], i);
 
+          _cuda_minloc2.minloc(a[i], i);
+          _cuda_maxloc2.maxloc(a[i], i);
+
         }
       );
 
@@ -323,6 +361,11 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT hip_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT hip_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int hip_min2 = std::numeric_limits<int>::max();
+  int hip_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type hip_minloc2(-1);
+  RAJA::Index_type hip_maxloc2(-1);
+
   RAJA::launch<LAUNCH_POL3>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(HIP_BLOCK_SIZE)),
      "HipReductionKernel",
@@ -331,12 +374,16 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&hip_min2, &hip_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&hip_max2, &hip_maxloc2),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           REF_INT_SUM &_hip_sum,
-                           REF_INT_MIN &_hip_min,
-                           REF_INT_MAX &_hip_max,
-                           REFLOC_INT_MIN &_hip_minloc,
-                           REFLOC_INT_MAX &_hip_maxloc) {
+                           VALOP_INT_SUM &_hip_sum,
+                           VALOP_INT_MIN &_hip_min,
+                           VALOP_INT_MAX &_hip_max,
+                           VALOPLOC_INT_MIN &_hip_minloc,
+                           VALOPLOC_INT_MAX &_hip_maxloc,
+                           VALOPLOC_INT_MIN &_hip_minloc2,
+                           VALOPLOC_INT_MAX &_hip_maxloc2) {
 
       RAJA::loop<LOOP_POL3>(ctx, arange, [&] (int i) {
 
@@ -348,6 +395,8 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
           _hip_minloc.minloc(d_a[i], i);
           _hip_maxloc.maxloc(d_a[i], i);
 
+          _hip_minloc2.minloc(d_a[i], i);
+          _hip_maxloc2.maxloc(d_a[i], i);
         }
       );
 
@@ -386,6 +435,11 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT sycl_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT sycl_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int sycl_min2 = std::numeric_limits<int>::max();
+  int sycl_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type sycl_minloc2(-1);
+  RAJA::Index_type sycl_maxloc2(-1);
+
   RAJA::launch<LAUNCH_POL4>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(SYCL_BLOCK_SIZE)),
      "SyclReductionKernel",
@@ -394,12 +448,16 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&sycl_min2, &sycl_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&sycl_max2, &sycl_maxloc2),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           REF_INT_SUM &_sycl_sum,
-                           REF_INT_MIN &_sycl_min,
-                           REF_INT_MAX &_sycl_max,
-                           REFLOC_INT_MIN &_sycl_minloc,
-                           REFLOC_INT_MAX &_sycl_maxloc) {
+                           VALOP_INT_SUM &_sycl_sum,
+                           VALOP_INT_MIN &_sycl_min,
+                           VALOP_INT_MAX &_sycl_max,
+                           VALOPLOC_INT_MIN &_sycl_minloc,
+                           VALOPLOC_INT_MAX &_sycl_maxloc,
+                           VALOPLOC_INT_MIN &_sycl_minloc2,
+                           VALOPLOC_INT_MAX &_sycl_maxloc2) {
 
       RAJA::loop<LOOP_POL4>(ctx, arange, [&] (int i) {
 
@@ -411,6 +469,8 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
           _sycl_minloc.minloc(d_a[i], i);
           _sycl_maxloc.maxloc(d_a[i], i);
 
+          _sycl_minloc2.minloc(d_a[i], i);
+          _sycl_maxloc2.maxloc(d_a[i], i);
         }
       );
 

From 806280967f3fae863c96ac9d5230a7660cdce0a9 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 19 Sep 2024 14:50:08 -0700
Subject: [PATCH 59/82] Attempt to make OpenMP ValOp reduction tests faster in
 CI.

---
 .../test-forall-basic-expt-ReduceMaxLoc.hpp    | 18 +++++++++++-------
 .../test-forall-basic-expt-ReduceMinLoc.hpp    | 18 +++++++++++-------
 2 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
index 231ac3e98f..827202dacf 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
@@ -101,29 +101,33 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   VL_TYPE max2(max_init, maxloc_init);
 
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&max2),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE RAJA_UNUSED_ARG(&m), VL_LAMBDA_TYPE &m2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
       m2.max( max );
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(max2.getVal()), static_cast<DATA_TYPE>(max.getVal()));
   ASSERT_EQ(static_cast<IDX_TYPE>(max2.getLoc()), static_cast<IDX_TYPE>(max.getLoc()));
 
   DATA_TYPE s_max = max_init;
-  DATA_TYPE s_max2 = max_init;
   IDX_TYPE s_maxloc = maxloc_init;
-  IDX_TYPE s_maxloc2 = maxloc_init;
 
   factor = 4;
   RAJA::forall<EXEC_POLICY>(seg,
     RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max, &s_maxloc),
-    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max2, &s_maxloc2),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m, VL_LAMBDA_TYPE &m2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
       m.maxloc( working_array[idx] * factor, idx);
-      m2.max(max2);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(s_max), ref_max * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(s_maxloc), ref_maxloc);
+
+  DATA_TYPE s_max2 = max_init;
+  IDX_TYPE s_maxloc2 = maxloc_init;
+
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max2, &s_maxloc2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
+      m2.max(max2);
+  });
   ASSERT_EQ(static_cast<DATA_TYPE>(s_max2), static_cast<DATA_TYPE>(max2.getVal()));
   ASSERT_EQ(static_cast<IDX_TYPE>(s_maxloc2), static_cast<IDX_TYPE>(max2.getLoc()));
 
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
index 6268c0dbd5..efe67c0f64 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
@@ -100,29 +100,33 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
   VL_TYPE min2(min_init, minloc_init);
 
   RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&min2),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE RAJA_UNUSED_ARG(&m), VL_LAMBDA_TYPE &m2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
       m2.min( min );
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(min2.getVal()), static_cast<DATA_TYPE>(min.getVal()));
   ASSERT_EQ(static_cast<IDX_TYPE>(min2.getLoc()), static_cast<IDX_TYPE>(min.getLoc()));
 
   DATA_TYPE s_min = min_init;
-  DATA_TYPE s_min2 = min_init;
   IDX_TYPE s_minloc = minloc_init;
-  IDX_TYPE s_minloc2 = minloc_init;
 
   factor = 4;
   RAJA::forall<EXEC_POLICY>(seg,
     RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min, &s_minloc),
-    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min2, &s_minloc2),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m, VL_LAMBDA_TYPE &m2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
       m.minloc( working_array[idx] * factor, idx);
-      m2.min(min2);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(s_min), ref_min * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(s_minloc), ref_minloc);
+
+  DATA_TYPE s_min2 = min_init;
+  IDX_TYPE s_minloc2 = minloc_init;
+
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min2, &s_minloc2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
+      m2.min(min2);
+  });
   ASSERT_EQ(static_cast<DATA_TYPE>(s_min2), static_cast<DATA_TYPE>(min2.getVal()));
   ASSERT_EQ(static_cast<IDX_TYPE>(s_minloc2), static_cast<IDX_TYPE>(min2.getLoc()));
    

From ab40dc51a2488626314b855ef5fded1a82809eba Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 19 Sep 2024 17:01:23 -0700
Subject: [PATCH 60/82] Comments on how Reducer object works with ValOp.

---
 include/RAJA/pattern/params/reducer.hpp | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 3bf68898dd..d5586b96dd 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -55,13 +55,19 @@ namespace detail
   // Basic Reducer
   //
   //
+
+  // For the standard use case, T can be a basic data type or a ValLoc, and DataType is the same as T.
+  // For the pass through use case, T is a ValLoc, and DataType is the underlying basic data type within the ValLoc.
+  // By default, we expect the standard use case, which is why passthru is set to false.
   template <template <typename, typename, typename> class Op, typename T, typename VType, typename DataType = T, typename IndexType = RAJA::Index_type, bool passthru = false>
   struct Reducer : public ForallParamBase {
     using op = Op<T,T,T>;
-    using value_type = T;
+    using value_type = T; // Can be basic data types, or ValLoc.
 
     RAJA_HOST_DEVICE Reducer() = default;
+    // Standard constructor
     RAJA_HOST_DEVICE Reducer(value_type *target_in) : valop_m(VType{}), target(target_in){}
+    // Pass through constructor
     RAJA_HOST_DEVICE Reducer(DataType *data_in, IndexType *index_in) : valop_m(VType(*data_in, *index_in)), target(&valop_m.val), passthruval(data_in), passthruindex(index_in) {}
 
     RAJA_HOST_DEVICE constexpr Reducer(Reducer const &) = default;
@@ -69,8 +75,18 @@ namespace detail
     RAJA_HOST_DEVICE Reducer& operator=(Reducer const &) = default;
     RAJA_HOST_DEVICE Reducer& operator=(Reducer &&) = default;
 
+    // VType should be a ValOp, and can accept basic data types or ValLoc's for T.
+    // Most internal reduction operations are performed on this.
+    // In the pass through use case, T is a ValLoc, and VType is ValOp<ValLoc>.
     VType valop_m = VType{};
+
+    // Points to the actual basic data type or ValLoc.
+    // This is set after valop_m has the final value.
     value_type *target = nullptr;
+
+    // Used when the pass through ReduceLoc(*data, *index) is called.
+    // These point to the actual data and index being passed in.
+    // These are set after valop_m has the final value.
     DataType *passthruval = nullptr;
     IndexType *passthruindex = nullptr; 
 
@@ -91,6 +107,7 @@ namespace detail
     unsigned int * device_count = nullptr;
 #endif
 
+    // These are types and parameters extracted from this struct, and given to the forall.
     using ARG_TUP_T = camp::tuple<VType*>;
     RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&valop_m); }
 
@@ -100,12 +117,14 @@ namespace detail
 
 } // namespace detail
 
+// Standard use case.
 template <template <typename, typename, typename> class Op, typename T, typename VType = ValOp<T, Op>>
 auto constexpr Reduce(T *target)
 {
   return detail::Reducer<Op, T, VType>(target);
 }
 
+// Pass through use case where reduction value and location are separate, non-ValLoc types.
 template <template <typename, typename, typename> class Op, typename T, typename IndexType = RAJA::Index_type, bool passingthru = true,
           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value> * = nullptr>
 auto constexpr ReduceLoc(T *target, IndexType *index)

From 3cca66f462d758bc049bfa13a22226b1cbbe43db Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 19 Sep 2024 17:01:40 -0700
Subject: [PATCH 61/82] Documentation on ValOp.

---
 docs/sphinx/user_guide/feature/reduction.rst | 108 ++++++++++++++-----
 1 file changed, 79 insertions(+), 29 deletions(-)

diff --git a/docs/sphinx/user_guide/feature/reduction.rst b/docs/sphinx/user_guide/feature/reduction.rst
index 6d4c8695d9..b3c8e02ebe 100644
--- a/docs/sphinx/user_guide/feature/reduction.rst
+++ b/docs/sphinx/user_guide/feature/reduction.rst
@@ -190,6 +190,9 @@ RAJA::expt::Reduce
 ..................
 ::
 
+  using VALOP_DOUBLE_SUM = RAJA::expt::ValOp<double, RAJA::operators::plus>;
+  using VALOP_DOUBLE_MIN = RAJA::expt::ValOp<double, RAJA::operators::minimum>;
+
   double* a = ...;
 
   double rs = 0.0;
@@ -198,9 +201,9 @@ RAJA::expt::Reduce
   RAJA::forall<EXEC_POL> ( Res, Seg,
   RAJA::expt::Reduce<RAJA::operators::plus>(&rs),
   RAJA::expt::Reduce<RAJA::operators::minimum>(&rm),
-  [=] (int i, double& _rs, double& _rm) {
+  [=] (int i, VALOP_DOUBLE_SUM& _rs, VALOP_DOUBLE_MIN& _rm) {
     _rs += a[i];
-    _rm = RAJA_MIN(a[i], _rm);
+    _rm.min(a[i]);
   }
   );
 
@@ -213,13 +216,14 @@ RAJA::expt::Reduce
   above. The reduction operation will include the existing value of
   the given target variable.
 * The kernel body lambda expression passed to ``RAJA::forall`` must have a
-  parameter corresponding to each ``RAJA::expt::Reduce`` argument, ``_rs`` and
-  ``_rm`` in the example code. These parameters refer to a local target for each
-  reduction operation. It is important to note that the parameters follow the
-  kernel iteration variable, ``i`` in this case, and appear in the same order
-  as the corresponding ``RAJA::expt::Reduce`` arguments to ``RAJA::forall``. The
-  parameter types must be references to the types used in the
-  ``RAJA::expt::Reduce`` arguments.
+  ``RAJA::expt::ValOp`` parameter corresponding to each ``RAJA::expt::Reduce``
+  argument, ``_rs`` and ``_rm`` in the example code. These parameters refer to a
+  local target for each reduction operation. Each ``ValOp`` needs to be templated
+  on the underlying data type (``double`` for ``_rs`` and ``_rm``), and the operator
+  being used. It is important to note that the parameters follow the kernel iteration
+  variable, ``i`` in this case, and appear in the same order as the corresponding
+  ``RAJA::expt::Reduce`` arguments to ``RAJA::forall``. The parameter types must be
+  references to the types used in the ``RAJA::expt::Reduce`` arguments.
 * The local variables referred to by ``_rs`` and ``_rm`` are initialized with
   the *identity* of the reduction operation to be performed.
 * The local variables are updated in the user supplied lambda.
@@ -236,10 +240,11 @@ RAJA::expt::Reduce
           compatible with the ``EXEC_POL``. ``Seg`` is the iteration space
           object for ``RAJA::forall``.
 
-.. important:: The order and types of the local reduction variables in the
-               kernel body lambda expression must match exactly with the
-               corresponding ``RAJA::expt::Reduce`` arguments to the
-               ``RAJA::forall`` to ensure that the correct result is obtained.
+.. important:: The order of the local reduction variables in the
+               kernel body lambda expression must be ``RAJA::expt::ValOp``s which
+               match exactly in the underlying reduction data type, and RAJA
+               operator, with the corresponding ``RAJA::expt::Reduce`` arguments
+               to the ``RAJA::forall`` to ensure that the correct result is obtained.
 
 RAJA::expt::ValLoc
 ..................
@@ -247,28 +252,62 @@ RAJA::expt::ValLoc
 As with the current RAJA reduction interface, the new interface supports *loc*
 reductions, which provide the ability to get a kernel/loop index at which the
 final reduction value was found. With this new interface, *loc* reductions
-are performed using ``ValLoc<T>`` types. Since they are strongly typed, they
-provide ``min()`` and ``max()`` operations that are equivalent to using
-``RAJA_MIN()`` or ``RAJA_MAX`` macros as demonstrated in the code example below.
-Users must use the ``getVal()`` and ``getLoc()`` methods to access the reduction
-results::
+are performed using ``ValLoc<T,I>`` types, where ``T`` is the underlying data type,
+and ``I`` is the index type. Users must use the ``getVal()`` and ``getLoc()``
+methods to access the reduction results.
+
+In the kernel body lambda expression, a ``ValLoc<T,I>`` must be wrapped in a
+``ValOp``, and passed to the lambda in the same order as the corresponding 
+``RAJA::expt::Reduce`` arguments, e.g. ``ValOp<ValLoc<T,I>, minimum>``.
+For convenience, the alias of ``RAJA::expt::ValLocOp<T,I,Op>`` can be used.
+Within the lambda, this ``ValLocOp`` object provides ``minloc``, and ``maxloc``
+functions::
 
   double* a = ...;
 
+  using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValOp<ValLoc<double, RAJA::Index_type>,
+                                                       RAJA::expt::minimum>;
+
   using VL_DOUBLE = RAJA::expt::ValLoc<double>;
   VL_DOUBLE rm_loc;
 
   RAJA::forall<EXEC_POL> ( Res, Seg,
   RAJA::expt::Reduce<RAJA::operators::minimum>(&rm_loc),
-  [=] (int i, VL_DOUBLE& _rm_loc) {
-    _rm_loc = RAJA_MIN(VL_DOUBLE(a[i], i), _rm_loc);
-    //_rm_loc.min(VL_DOUBLE(a[i], i)); // Alternative to RAJA_MIN
+  [=] (int i, VALOPLOC_DOUBLE_MIN& _rm_loc) {
+    _rm_loc.minloc(a[i], i);
   }
   );
 
   std::cout << rm_loc.getVal() ...
   std::cout << rm_loc.getLoc() ...
 
+Alternatively, *loc* reductions can be performed on separate reduction data, and
+location variables without a ``ValLoc``. The change required is to pass
+a ``RAJA::expt::ReduceLoc`` argument to the forall, templated on the reduction
+operation, and passing in references to the data and location in that respective
+order. The data and location can be accessed outside for the forall directly
+without ``getVal()`` or ``getLoc()`` functions.
+:: 
+
+  double* a = ...;
+
+  using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValOp<ValLoc<double, RAJA::Index_type>,
+                                                       RAJA::expt::minimum>;
+
+  double rm;
+  RAJA::Index_type loc;
+
+  RAJA::forall<EXEC_POL> ( Res, Seg,
+  RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&rm, &loc),
+  [=] (int i, VALOPLOC_DOUBLE_MIN& _rm_loc) {
+    _rm_loc.minloc(a[i], i);
+  }
+  );
+
+  std::cout << rm ...
+  std::cout << loc ...
+
+
 Lambda Arguments
 ................
 
@@ -277,6 +316,10 @@ any number of ``RAJA::expt::Reduce`` objects to the ``RAJA::forall`` method::
 
   double* a = ...;
 
+  using VALOP_DOUBLE_SUM = RAJA::expt::ValOp<double, RAJA::operators::plus>;
+  using VALOP_DOUBLE_MIN = RAJA::expt::ValOp<double, RAJA::operators::minimum>;
+  using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValLocOp<double, RAJA::Index_type, RAJA::operators::minimum>;
+
   using VL_DOUBLE = RAJA::expt::ValLoc<double>;
   VL_DOUBLE rm_loc;
   double rs;
@@ -287,10 +330,13 @@ any number of ``RAJA::expt::Reduce`` objects to the ``RAJA::forall`` method::
     RAJA::expt::Reduce<RAJA::operators::minimum>(&rm),     // --> 1 double added
     RAJA::expt::Reduce<RAJA::operators::minimum>(&rm_loc), // --> 1 VL_DOUBLE added
     RAJA::expt::KernelName("MyFirstRAJAKernel"),           // --> NO args added
-    [=] (int i, double& _rs, double& _rm, VL_DOUBLE& _rm_loc) {
+    [=] (int i,
+         VALOP_DOUBLE_SUM& _rs,
+         VALOP_DOUBLE_MIN& _rm,
+         VALOPLOC_DOUBLE_MIN& _rm_loc) {
       _rs += a[i];
-      _rm = RAJA_MIN(a[i], _rm);
-      _rm_loc.min(VL_DOUBLE(a[i], i));
+      _rm.min(a[i]);
+      _rm_loc.minloc(a[i], i);
     }
   );
 
@@ -300,9 +346,10 @@ any number of ``RAJA::expt::Reduce`` objects to the ``RAJA::forall`` method::
   std::cout << rm_loc.getLoc() ...
 
 Again, the lambda expression parameters are in the same order as
-the ``RAJA::expt::Reduce`` arguments to ``RAJA::forall``. Both the types and
-order of the parameters must match to get correct results and to compile
-successfully. Otherwise, a static assertion will be triggered::
+the ``RAJA::expt::Reduce`` arguments to ``RAJA::forall``. The ``ValOp`` underlying
+data types and operators, and order of the ``ValOp`` parameters must match 
+the corresponding ``RAJA::expt::Reduce`` types to get correct results and to
+compile successfully. Otherwise, a static assertion will be triggered::
 
   LAMBDA Not invocable w/ EXPECTED_ARGS.
 
@@ -329,6 +376,9 @@ The usage of the experiemental reductions is similar to the forall example as il
 
   double* a = ...;
 
+  using VALOP_DOUBLE_SUM = RAJA::expt::ValOp<double, RAJA::operators::plus>;
+  using VALOP_DOUBLE_MIN = RAJA::expt::ValOp<double, RAJA::operators::minimum>;
+
   double rs = 0.0;
   double rm = 1e100;
 
@@ -336,12 +386,12 @@ The usage of the experiemental reductions is similar to the forall example as il
     RAJA::expt::Reduce<RAJA::operators::plus>(&rs),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&rm),
     "LaunchReductionKernel",
-    [=] RAJA_HOST_DEVICE (int i, double& _rs, double& _rm) {
+    [=] RAJA_HOST_DEVICE (int i, VALOP_DOUBLE_SUM& _rs, VALOP_DOUBLE_MIN& _rm) {
 
       RAJA::loop<loop_pol>(ctx, Seg, [&] (int i) {
 
         _rs += a[i];
-        _rm = RAJA_MIN(a[i], _rm);
+        _rm.min(a[i], _rm);
 
         }
       );

From 59482fa9c2f1c872318f81c708e8d4ff0bd3e784 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 20 Sep 2024 09:05:33 -0700
Subject: [PATCH 62/82] Fix GPU compiler warnings for decorated constructors.

---
 include/RAJA/pattern/params/params_base.hpp | 30 ++++++++++-----------
 include/RAJA/pattern/params/reducer.hpp     | 11 ++++----
 2 files changed, 21 insertions(+), 20 deletions(-)

diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index 36759bd4fb..148c4098b1 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -12,14 +12,14 @@ namespace expt
     using index_type = IndexType;
     using value_type = T;
 
-    RAJA_HOST_DEVICE constexpr ValLoc() = default;
+    ValLoc() = default;
     RAJA_HOST_DEVICE constexpr explicit ValLoc(value_type v) : val(v) {}
     RAJA_HOST_DEVICE constexpr explicit ValLoc(value_type v, index_type l) : val(v), loc(l) {}
 
-    RAJA_HOST_DEVICE constexpr ValLoc(ValLoc const &) = default;
-    RAJA_HOST_DEVICE constexpr ValLoc(ValLoc &&) = default;
-    RAJA_HOST_DEVICE ValLoc& operator=(ValLoc const &) = default;
-    RAJA_HOST_DEVICE ValLoc& operator=(ValLoc &&) = default;
+    ValLoc(ValLoc const &) = default;
+    ValLoc(ValLoc &&) = default;
+    ValLoc& operator=(ValLoc const &) = default;
+    ValLoc& operator=(ValLoc &&) = default;
 
     RAJA_HOST_DEVICE constexpr bool operator<(const ValLoc& rhs) const { return val < rhs.val; }
     RAJA_HOST_DEVICE constexpr bool operator>(const ValLoc& rhs) const { return val > rhs.val; }
@@ -38,13 +38,13 @@ namespace expt
     using value_type = T;
     using op_type = Op<T,T,T>;
 
-    RAJA_HOST_DEVICE constexpr ValOp() = default;
+    ValOp() = default;
     RAJA_HOST_DEVICE constexpr explicit ValOp(value_type v) : val(v) {}
 
-    RAJA_HOST_DEVICE constexpr ValOp(ValOp const &) = default;
-    RAJA_HOST_DEVICE constexpr ValOp(ValOp &&) = default;
-    RAJA_HOST_DEVICE ValOp& operator=(ValOp const &) = default;
-    RAJA_HOST_DEVICE ValOp& operator=(ValOp &&) = default;
+    ValOp(ValOp const &) = default;
+    ValOp(ValOp &&) = default;
+    ValOp& operator=(ValOp const &) = default;
+    ValOp& operator=(ValOp &&) = default;
 
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<T,T,T>>::value> * = nullptr>
     RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
@@ -80,14 +80,14 @@ namespace expt
     using valloc_value_type = typename value_type::value_type;
     using valloc_index_type = typename value_type::index_type;
 
-    RAJA_HOST_DEVICE constexpr ValOp() = default;
+    ValOp() = default;
     RAJA_HOST_DEVICE constexpr explicit ValOp(value_type v) : val(v) {}
     RAJA_HOST_DEVICE constexpr explicit ValOp(valloc_value_type v, valloc_index_type l) : val(v, l) {}
 
-    RAJA_HOST_DEVICE constexpr ValOp(ValOp const &) = default;
-    RAJA_HOST_DEVICE constexpr ValOp(ValOp &&) = default;
-    RAJA_HOST_DEVICE ValOp& operator=(ValOp const &) = default;
-    RAJA_HOST_DEVICE ValOp& operator=(ValOp &&) = default;
+    ValOp(ValOp const &) = default;
+    ValOp(ValOp &&) = default;
+    ValOp& operator=(ValOp const &) = default;
+    ValOp& operator=(ValOp &&) = default;
 
     template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
     RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index d5586b96dd..808966d7e5 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -64,16 +64,16 @@ namespace detail
     using op = Op<T,T,T>;
     using value_type = T; // Can be basic data types, or ValLoc.
 
-    RAJA_HOST_DEVICE Reducer() = default;
+    Reducer() = default;
     // Standard constructor
     RAJA_HOST_DEVICE Reducer(value_type *target_in) : valop_m(VType{}), target(target_in){}
     // Pass through constructor
     RAJA_HOST_DEVICE Reducer(DataType *data_in, IndexType *index_in) : valop_m(VType(*data_in, *index_in)), target(&valop_m.val), passthruval(data_in), passthruindex(index_in) {}
 
-    RAJA_HOST_DEVICE constexpr Reducer(Reducer const &) = default;
-    RAJA_HOST_DEVICE constexpr Reducer(Reducer &&) = default;
-    RAJA_HOST_DEVICE Reducer& operator=(Reducer const &) = default;
-    RAJA_HOST_DEVICE Reducer& operator=(Reducer &&) = default;
+    Reducer(Reducer const &) = default;
+    Reducer(Reducer &&) = default;
+    Reducer& operator=(Reducer const &) = default;
+    Reducer& operator=(Reducer &&) = default;
 
     // VType should be a ValOp, and can accept basic data types or ValLoc's for T.
     // Most internal reduction operations are performed on this.
@@ -82,6 +82,7 @@ namespace detail
 
     // Points to the actual basic data type or ValLoc.
     // This is set after valop_m has the final value.
+    // Note that in the pass through use case, target points to the ValLoc in valop_m.val, because the user did not provide a ValLoc target.
     value_type *target = nullptr;
 
     // Used when the pass through ReduceLoc(*data, *index) is called.

From 9adc6f771cde837f4819b16ddd925a20e9a3736c Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 20 Sep 2024 09:06:21 -0700
Subject: [PATCH 63/82] Documentation fix.

---
 docs/sphinx/user_guide/feature/reduction.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/sphinx/user_guide/feature/reduction.rst b/docs/sphinx/user_guide/feature/reduction.rst
index b3c8e02ebe..5d6b9b58ef 100644
--- a/docs/sphinx/user_guide/feature/reduction.rst
+++ b/docs/sphinx/user_guide/feature/reduction.rst
@@ -241,7 +241,7 @@ RAJA::expt::Reduce
           object for ``RAJA::forall``.
 
 .. important:: The order of the local reduction variables in the
-               kernel body lambda expression must be ``RAJA::expt::ValOp``s which
+               kernel body lambda expression must ``RAJA::expt::ValOp`` objects which
                match exactly in the underlying reduction data type, and RAJA
                operator, with the corresponding ``RAJA::expt::Reduce`` arguments
                to the ``RAJA::forall`` to ensure that the correct result is obtained.

From 09ab606c17daaf96f1af8ec0911b05e9e54b90c9 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 26 Sep 2024 17:05:56 -0700
Subject: [PATCH 64/82] Minor updates for ValLoc.

---
 include/RAJA/pattern/params/params_base.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index 148c4098b1..98380f6ffc 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -14,7 +14,7 @@ namespace expt
 
     ValLoc() = default;
     RAJA_HOST_DEVICE constexpr explicit ValLoc(value_type v) : val(v) {}
-    RAJA_HOST_DEVICE constexpr explicit ValLoc(value_type v, index_type l) : val(v), loc(l) {}
+    RAJA_HOST_DEVICE constexpr ValLoc(value_type v, index_type l) : val(v), loc(l) {}
 
     ValLoc(ValLoc const &) = default;
     ValLoc(ValLoc &&) = default;
@@ -28,6 +28,8 @@ namespace expt
     RAJA_HOST_DEVICE constexpr const index_type& getLoc() const {return loc;}
 
     RAJA_HOST_DEVICE void set(T inval, IndexType inindex) {val = inval; loc = inindex;}
+    RAJA_HOST_DEVICE void setVal(T inval) {val = inval;}
+    RAJA_HOST_DEVICE void setLoc(IndexType inindex) {loc = inindex;}
 
     value_type val;
     index_type loc = -1;
@@ -82,7 +84,7 @@ namespace expt
 
     ValOp() = default;
     RAJA_HOST_DEVICE constexpr explicit ValOp(value_type v) : val(v) {}
-    RAJA_HOST_DEVICE constexpr explicit ValOp(valloc_value_type v, valloc_index_type l) : val(v, l) {}
+    RAJA_HOST_DEVICE constexpr ValOp(valloc_value_type v, valloc_index_type l) : val(v, l) {}
 
     ValOp(ValOp const &) = default;
     ValOp(ValOp &&) = default;

From 2be498934db22d5646128849c140a8e1fa180b70 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 26 Sep 2024 17:06:27 -0700
Subject: [PATCH 65/82] Simplify Reducer internals.

---
 include/RAJA/pattern/params/reducer.hpp | 104 ++++++++++++++++++------
 1 file changed, 77 insertions(+), 27 deletions(-)

diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 808966d7e5..9d25df692e 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -56,50 +56,92 @@ namespace detail
   //
   //
 
-  // For the standard use case, T can be a basic data type or a ValLoc, and DataType is the same as T.
-  // For the pass through use case, T is a ValLoc, and DataType is the underlying basic data type within the ValLoc.
-  // By default, we expect the standard use case, which is why passthru is set to false.
-  template <template <typename, typename, typename> class Op, typename T, typename VType, typename DataType = T, typename IndexType = RAJA::Index_type, bool passthru = false>
+  // Basic data type Reducer
+  // T must be a basic data type
+  // IndexType not used here
+  // VType must be ValOp<T, Op>
+  template <template <typename, typename, typename> class Op, typename T, typename IndexType, typename VType>
   struct Reducer : public ForallParamBase {
     using op = Op<T,T,T>;
-    using value_type = T; // Can be basic data types, or ValLoc.
+    using value_type = T; // This is a basic data type
 
     Reducer() = default;
-    // Standard constructor
+
+    // Basic data type constructor
     RAJA_HOST_DEVICE Reducer(value_type *target_in) : valop_m(VType{}), target(target_in){}
-    // Pass through constructor
-    RAJA_HOST_DEVICE Reducer(DataType *data_in, IndexType *index_in) : valop_m(VType(*data_in, *index_in)), target(&valop_m.val), passthruval(data_in), passthruindex(index_in) {}
 
     Reducer(Reducer const &) = default;
     Reducer(Reducer &&) = default;
     Reducer& operator=(Reducer const &) = default;
     Reducer& operator=(Reducer &&) = default;
 
-    // VType should be a ValOp, and can accept basic data types or ValLoc's for T.
-    // Most internal reduction operations are performed on this.
-    // In the pass through use case, T is a ValLoc, and VType is ValOp<ValLoc>.
+    // Internal ValOp object that is used within RAJA::forall/launch
     VType valop_m = VType{};
 
-    // Points to the actual basic data type or ValLoc.
-    // This is set after valop_m has the final value.
-    // Note that in the pass through use case, target points to the ValLoc in valop_m.val, because the user did not provide a ValLoc target.
+    // Points to the user specified result variable
     value_type *target = nullptr;
 
-    // Used when the pass through ReduceLoc(*data, *index) is called.
-    // These point to the actual data and index being passed in.
-    // These are set after valop_m has the final value.
-    DataType *passthruval = nullptr;
-    IndexType *passthruindex = nullptr; 
+    // Used in the resolve() call to set target in each backend
+    RAJA_HOST_DEVICE void set(value_type in) { *target = in; }
 
-    template <typename U = VType, std::enable_if_t<std::is_same<U,ValOp<T,Op>>::value>* = nullptr>
     RAJA_HOST_DEVICE
     value_type &
     getVal() { return valop_m.val; }
 
-    template <typename U = VType, std::enable_if_t<std::is_same<U,ValOp<ValLoc<T,IndexType>,Op>>::value>* = nullptr>
+#if defined(RAJA_CUDA_ACTIVE) || defined(RAJA_HIP_ACTIVE) || defined(RAJA_SYCL_ACTIVE)
+    // Device related attributes.
+    value_type * devicetarget = nullptr;
+    RAJA::detail::SoAPtr<value_type, device_mem_pool_t> device_mem;
+    unsigned int * device_count = nullptr;
+#endif
+
+    // These are types and parameters extracted from this struct, and given to the forall.
+    using ARG_TUP_T = camp::tuple<VType*>;
+    RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&valop_m); }
+
+    using ARG_LIST_T = typename ARG_TUP_T::TList;
+    static constexpr size_t num_lambda_args = camp::tuple_size<ARG_TUP_T>::value ;
+  };
+
+  // Partial specialization of Reducer for ValLoc
+  // T must be a basic data type
+  // VType must be ValOp<ValLoc<T,IndexType>,Op>
+  template <template <typename, typename, typename> class Op, typename T, typename IndexType>
+  struct Reducer<Op, T, IndexType, ValOp<ValLoc<T,IndexType>, Op>> : public ForallParamBase {
+    using value_type = ValLoc<T,IndexType>; // Note that this struct operates on ValLoc
+    using op = Op<value_type,value_type,value_type>;
+    using VType = ValOp<ValLoc<T,IndexType>, Op>;
+
+    Reducer() = default;
+
+    // ValLoc constructor
+    // Note that the passthru variables point to the val and loc within the user defined target ValLoc
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : valop_m(VType{}), target(target_in), passthruval(&target_in->val), passthruindex(&target_in->loc) {}
+
+    // Pass through constructor for ReduceLoc<>(data, index) case
+    // The passthru variables point to vars defined by the user
+    RAJA_HOST_DEVICE Reducer(T *data_in, IndexType *index_in) : valop_m(VType(*data_in, *index_in)), target(&valop_m.val), passthruval(data_in), passthruindex(index_in) {}
+
+    Reducer(Reducer const &) = default;
+    Reducer(Reducer &&) = default;
+    Reducer& operator=(Reducer const &) = default;
+    Reducer& operator=(Reducer &&) = default;
+
+    VType valop_m = VType{};
+
+    value_type *target = nullptr;
+
+    T *passthruval = nullptr;
+    IndexType *passthruindex = nullptr;
+
+    // This single-argument set() matches the basic data type Reducer::set()'s
+    // function signature to make the init/combine/resolve backend calls easier
+    // to maintain, but operates on the passthru variables instead
+    RAJA_HOST_DEVICE void set(value_type in) { *passthruval = in.val; *passthruindex = in.loc; }
+
     RAJA_HOST_DEVICE
     value_type &
-    getVal() { return valop_m.val.val; }
+    getVal() { return valop_m.val; }
 
 #if defined(RAJA_CUDA_ACTIVE) || defined(RAJA_HIP_ACTIVE) || defined(RAJA_SYCL_ACTIVE)
     // Device related attributes.
@@ -119,18 +161,26 @@ namespace detail
 } // namespace detail
 
 // Standard use case.
-template <template <typename, typename, typename> class Op, typename T, typename VType = ValOp<T, Op>>
+template <template <typename, typename, typename> class Op, typename T, typename IndexType = RAJA::Index_type,
+          std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value> * = nullptr>
 auto constexpr Reduce(T *target)
 {
-  return detail::Reducer<Op, T, VType>(target);
+  return detail::Reducer<Op, T, IndexType, ValOp<T, Op>>(target);
+}
+
+// User-defined ValLoc case.
+template <template <typename, typename, typename> class Op, typename T, typename IndexType>
+auto constexpr Reduce(ValLoc<T, IndexType> *target)
+{
+  return detail::Reducer<Op, T, IndexType, ValOp<ValLoc<T, IndexType>, Op>>(target);
 }
 
-// Pass through use case where reduction value and location are separate, non-ValLoc types.
-template <template <typename, typename, typename> class Op, typename T, typename IndexType = RAJA::Index_type, bool passingthru = true,
+// Pass through use case where reduction value and location are separate, non-ValLoc types supplied by the user.
+template <template <typename, typename, typename> class Op, typename T, typename IndexType,
           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value> * = nullptr>
 auto constexpr ReduceLoc(T *target, IndexType *index)
 {
-  return detail::Reducer<Op, ValLoc<T, IndexType>, ValLocOp<T, IndexType, Op>, T, IndexType, passingthru>(target, index);
+  return detail::Reducer<Op, T, IndexType, ValOp<ValLoc<T, IndexType>, Op>>(target, index);
 }
 
 } // namespace expt

From 6616abe3374f770ba42755f2ccc8a0e94d0e13a8 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 26 Sep 2024 17:07:04 -0700
Subject: [PATCH 66/82] Remove old grid_reduce for expt Reducer.

---
 include/RAJA/policy/cuda/reduce.hpp | 47 ----------------------------
 include/RAJA/policy/hip/reduce.hpp  | 48 -----------------------------
 2 files changed, 95 deletions(-)

diff --git a/include/RAJA/policy/cuda/reduce.hpp b/include/RAJA/policy/cuda/reduce.hpp
index 87130ddfe8..d55f1035a8 100644
--- a/include/RAJA/policy/cuda/reduce.hpp
+++ b/include/RAJA/policy/cuda/reduce.hpp
@@ -324,53 +324,6 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
   }
 }
 
-template <typename GlobalIterationGetter, template <typename, typename, typename> class OP, typename T>
-RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T, T>& red)
-{
-  using BlockIterationGetter = typename get_index_block<GlobalIterationGetter>::type;
-  using ThreadIterationGetter = typename get_index_thread<GlobalIterationGetter>::type;
-
-  const int numBlocks = BlockIterationGetter::size();
-  const int numThreads = ThreadIterationGetter::size();
-  const unsigned int wrap_around = numBlocks - 1;
-
-  const int blockId = BlockIterationGetter::index();
-  const int threadId = ThreadIterationGetter::index();
-
-  T temp = block_reduce<ThreadIterationGetter, OP>(red.val, OP<T,T,T>::identity());
-
-  // one thread per block writes to device_mem
-  bool lastBlock = false;
-  if (threadId == 0) {
-    red.device_mem.set(blockId, temp);
-    // ensure write visible to all threadblocks
-    __threadfence();
-    // increment counter, (wraps back to zero if old count == wrap_around)
-    unsigned int old_count = ::atomicInc(red.device_count, wrap_around);
-    lastBlock = (old_count == wrap_around);
-  }
-
-  // returns non-zero value if any thread passes in a non-zero value
-  lastBlock = __syncthreads_or(lastBlock);
-
-  // last block accumulates values from device_mem
-  if (lastBlock) {
-    temp = OP<T,T,T>::identity();
-    __threadfence();
-
-    for (int i = threadId; i < numBlocks; i += numThreads) {
-      temp = OP<T,T,T>{}(temp, red.device_mem.get(i));
-    }
-
-    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP<T,T,T>::identity());
-
-    // one thread returns value
-    if (threadId == 0) {
-      *(red.devicetarget) = temp;
-    }
-  }
-}
-
 } //  namespace expt
 
 
diff --git a/include/RAJA/policy/hip/reduce.hpp b/include/RAJA/policy/hip/reduce.hpp
index 567712f29a..d29d4ec979 100644
--- a/include/RAJA/policy/hip/reduce.hpp
+++ b/include/RAJA/policy/hip/reduce.hpp
@@ -318,54 +318,6 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
   }
 }
 
-
-template <typename GlobalIterationGetter, template <typename, typename, typename> class OP, typename T>
-RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T, T>& red)
-{
-  using BlockIterationGetter = typename get_index_block<GlobalIterationGetter>::type;
-  using ThreadIterationGetter = typename get_index_thread<GlobalIterationGetter>::type;
-
-  const int numBlocks = BlockIterationGetter::size();
-  const int numThreads = ThreadIterationGetter::size();
-  const unsigned int wrap_around = numBlocks - 1;
-
-  const int blockId = BlockIterationGetter::index();
-  const int threadId = ThreadIterationGetter::index();
-
-  T temp = block_reduce<ThreadIterationGetter, OP>(red.val, OP<T,T,T>::identity());
-
-  // one thread per block writes to device_mem
-  bool lastBlock = false;
-  if (threadId == 0) {
-    red.device_mem.set(blockId, temp);
-    // ensure write visible to all threadblocks
-    __threadfence();
-    // increment counter, (wraps back to zero if old count == wrap_around)
-    unsigned int old_count = ::atomicInc(red.device_count, wrap_around);
-    lastBlock = (old_count == wrap_around);
-  }
-
-  // returns non-zero value if any thread passes in a non-zero value
-  lastBlock = __syncthreads_or(lastBlock);
-
-  // last block accumulates values from device_mem
-  if (lastBlock) {
-    temp = OP<T,T,T>::identity();
-    __threadfence();
-
-    for (int i = threadId; i < numBlocks; i += numThreads) {
-      temp = OP<T,T,T>{}(temp, red.device_mem.get(i));
-    }
-
-    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP<T,T,T>::identity());
-
-    // one thread returns value
-    if (threadId == 0) {
-      *(red.devicetarget) = temp;
-    }
-  }
-}
-
 } //  namespace expt
 
 

From 94b4fbf8d0655960934760f6defca463f17902c7 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 26 Sep 2024 17:07:43 -0700
Subject: [PATCH 67/82] Update backends with new Reducer internals.

---
 include/RAJA/policy/cuda/params/reduce.hpp    | 63 ++++---------------
 include/RAJA/policy/hip/params/reduce.hpp     | 63 ++++---------------
 include/RAJA/policy/openmp/params/reduce.hpp  | 44 ++++---------
 .../policy/openmp_target/params/reduce.hpp    | 44 ++++---------
 .../RAJA/policy/sequential/params/reduce.hpp  | 45 ++++---------
 include/RAJA/policy/sycl/params/reduce.hpp    | 44 ++++---------
 6 files changed, 73 insertions(+), 230 deletions(-)

diff --git a/include/RAJA/policy/cuda/params/reduce.hpp b/include/RAJA/policy/cuda/params/reduce.hpp
index e8dde1087d..1cfd6df535 100644
--- a/include/RAJA/policy/cuda/params/reduce.hpp
+++ b/include/RAJA/policy/cuda/params/reduce.hpp
@@ -15,79 +15,40 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType, D, I, true>& red, RAJA::cuda::detail::cudaInfo& ci)
+  init(Reducer<OP, T, I, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
-    red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<VT>(1);
     red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
     red.device_count = RAJA::cuda::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType, D, I, true>& red)
+  combine(Reducer<OP, T, I, VType>& red)
   {
-    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP, T>(red.devicetarget,
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP, VT>(red.devicetarget,
                                                                             red.getVal(),
                                                                             red.device_mem,
                                                                             red.device_count);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType, D, I, true>& red, RAJA::cuda::detail::cudaInfo& ci)
+  resolve(Reducer<OP, T, I, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
-    // complete reduction
-    ci.res.wait();
-
-    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
-
-    *red.passthruval = red.target->val;
-    *red.passthruindex = red.target->loc;
-
-    // free memory
-    RAJA::cuda::device_zeroed_mempool_type::getInstance().free(red.device_count);
-    red.device_count = nullptr;
-    red.device_mem.deallocate();
-    RAJA::cuda::pinned_mempool_type::getInstance().free(red.devicetarget);
-    red.devicetarget = nullptr;
-  }
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
 
-  // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType, D, I, false>& red, RAJA::cuda::detail::cudaInfo& ci)
-  {
-    red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
-    red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
-    red.device_count = RAJA::cuda::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
-  }
-
-  // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  RAJA_HOST_DEVICE
-  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType, D, I, false>& red)
-  {
-    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP, T>(red.devicetarget,
-                                                                            red.getVal(),
-                                                                            red.device_mem,
-                                                                            red.device_count);
-  }
-
-  // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType, D, I, false>& red, RAJA::cuda::detail::cudaInfo& ci)
-  {
     // complete reduction
     ci.res.wait();
 
-    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
+    red.set(OP<VT,VT,VT>{}(*red.target, *red.devicetarget));
 
     // free memory
     RAJA::cuda::device_zeroed_mempool_type::getInstance().free(red.device_count);
diff --git a/include/RAJA/policy/hip/params/reduce.hpp b/include/RAJA/policy/hip/params/reduce.hpp
index 687d170982..b91dd7b3f4 100644
--- a/include/RAJA/policy/hip/params/reduce.hpp
+++ b/include/RAJA/policy/hip/params/reduce.hpp
@@ -13,77 +13,40 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType, D, I, true>& red, RAJA::hip::detail::hipInfo& hi)
+  init(Reducer<OP, T, I, VType>& red, RAJA::hip::detail::hipInfo& hi)
   {
-    red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<VT>(1);
     red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
     red.device_count = RAJA::hip::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType, D, I, true>& red)
+  combine(Reducer<OP, T, I, VType>& red)
   {
-    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP,T>( red.devicetarget,
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP,VT>( red.devicetarget,
                                                                             red.getVal(),
                                                                             red.device_mem,
                                                                             red.device_count);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType, D, I, true>& red, RAJA::hip::detail::hipInfo& hi)
+  resolve(Reducer<OP, T, I, VType>& red, RAJA::hip::detail::hipInfo& hi)
   {
-    // complete reduction
-    hi.res.wait();
-    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
-
-    *red.passthruval = red.target->val;
-    *red.passthruindex = red.target->loc;
-
-    // free memory
-    RAJA::hip::device_zeroed_mempool_type::getInstance().free(red.device_count);
-    red.device_count = nullptr;
-    red.device_mem.deallocate();
-    RAJA::hip::pinned_mempool_type::getInstance().free(red.devicetarget);
-    red.devicetarget = nullptr;
-  }
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
 
-  // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType, D, I, false>& red, RAJA::hip::detail::hipInfo& hi)
-  {
-    red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
-    red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
-    red.device_count = RAJA::hip::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
-  }
-
-  // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  RAJA_HOST_DEVICE
-  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType, D, I, false>& red)
-  {
-    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP,T>( red.devicetarget,
-                                                                            red.getVal(),
-                                                                            red.device_mem,
-                                                                            red.device_count);
-  }
-
-  // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType, D, I, false>& red, RAJA::hip::detail::hipInfo& hi)
-  {
     // complete reduction
     hi.res.wait();
-    *red.target = OP<T,T,T>{}(*red.target, *red.devicetarget);
+
+    red.set(OP<VT,VT,VT>{}(*red.target, *red.devicetarget));
 
     // free memory
     RAJA::hip::device_zeroed_mempool_type::getInstance().free(red.device_count);
diff --git a/include/RAJA/policy/openmp/params/reduce.hpp b/include/RAJA/policy/openmp/params/reduce.hpp
index a139f2c031..c8fcd596d2 100644
--- a/include/RAJA/policy/openmp/params/reduce.hpp
+++ b/include/RAJA/policy/openmp/params/reduce.hpp
@@ -10,47 +10,27 @@ namespace detail {
 #if defined(RAJA_ENABLE_OPENMP)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType, D, I, true>& red) {
-    red.valop_m.val = OP<T,T,T>::identity();
+  init(Reducer<OP, T, I, VType>& red) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    red.valop_m.val = OP<VT,VT,VT>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType, D, I, true>& out, const Reducer<OP, T, VType, D, I, true>& in) {
-    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
+  combine(Reducer<OP, T, I, VType>& out, const Reducer<OP, T, I, VType>& in) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    out.valop_m.val = OP<VT,VT,VT>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType, D, I, true>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
-    *red.passthruval = red.valop_m.val.val;
-    *red.passthruindex = red.valop_m.val.loc;
-  }
-
-  // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType, D, I, false>& red) {
-    red.valop_m.val = OP<T,T,T>::identity();
-  }
-
-  // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType, D, I, false>& out, const Reducer<OP, T, VType, D, I, false>& in) {
-    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
-  }
-
-  // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType, D, I, false>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
+  resolve(Reducer<OP, T, I, VType>& red) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    red.set(OP<VT,VT,VT>{}(*red.target, red.valop_m.val));
   }
 
 #endif
diff --git a/include/RAJA/policy/openmp_target/params/reduce.hpp b/include/RAJA/policy/openmp_target/params/reduce.hpp
index 18c2f72e06..fdca8109d8 100644
--- a/include/RAJA/policy/openmp_target/params/reduce.hpp
+++ b/include/RAJA/policy/openmp_target/params/reduce.hpp
@@ -10,47 +10,27 @@ namespace detail {
 #if defined(RAJA_ENABLE_TARGET_OPENMP)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType, D, I, true>& red) {
-    red.valop_m.val = OP<T,T,T>::identity();
+  init(Reducer<OP, T, I, VType>& red) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    red.valop_m.val = OP<VT,VT,VT>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType, D, I, true>& out, const Reducer<OP, T, VType, D, I, true>& in) {
-    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
+  combine(Reducer<OP, T, I, VType>& out, const Reducer<OP, T, I, VType>& in) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    out.valop_m.val = OP<VT,VT,VT>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType, D, I, true>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
-    *red.passthruval = red.valop_m.val.val;
-    *red.passthruindex = red.valop_m.val.loc;
-  }
-
-  // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
-  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red) {
-    red.valop_m.val = OP<T,T,T>::identity();
-  }
-
-  // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
-  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
-  }
-
-  // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename VType>
-  camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
+  resolve(Reducer<OP, T, I, VType>& red) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    red.set(OP<VT,VT,VT>{}(*red.target, red.valop_m.val));
   }
 
 #endif
diff --git a/include/RAJA/policy/sequential/params/reduce.hpp b/include/RAJA/policy/sequential/params/reduce.hpp
index 7a0b447a83..8f70b8eafc 100644
--- a/include/RAJA/policy/sequential/params/reduce.hpp
+++ b/include/RAJA/policy/sequential/params/reduce.hpp
@@ -8,48 +8,27 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  init(Reducer<OP, T, VType, D, I, true>& red) {
-    red.valop_m.val = OP<T,T,T>::identity();
+  init(Reducer<OP, T, I, VType>& red) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    red.valop_m.val = OP<VT,VT,VT>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  combine(Reducer<OP, T, VType, D, I, true>& out, const Reducer<OP, T, VType, D, I, true>& in) {
-    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
+  combine(Reducer<OP, T, I, VType>& out, const Reducer<OP, T, I, VType>& in) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    out.valop_m.val = OP<VT,VT,VT>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  resolve(Reducer<OP, T, VType, D, I, true>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
-    *red.passthruval = red.valop_m.val.val;
-    *red.passthruindex = red.valop_m.val.loc;
-  }
-
-
-  // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  init(Reducer<OP, T, VType, D, I, false>& red) {
-    red.valop_m.val = OP<T,T,T>::identity();
-  }
-
-  // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  combine(Reducer<OP, T, VType, D, I, false>& out, const Reducer<OP, T, VType, D, I, false>& in) {
-    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
-  }
-
-  // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  resolve(Reducer<OP, T, VType, D, I, false>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
+  resolve(Reducer<OP, T, I, VType>& red) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    red.set(OP<VT,VT,VT>{}(*red.target, red.valop_m.val));
   }
 
 } //  namespace detail
diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index b76917bac5..4e94a8695c 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -10,47 +10,27 @@ namespace detail {
 #if defined(RAJA_ENABLE_SYCL)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType, D, I, true>& red) {
-    red.valop_m.val = OP<T,T,T>::identity();
+  init(Reducer<OP, T, I, VType>& red) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    red.valop_m.val = OP<VT,VT,VT>::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType, D, I, true>& out, const Reducer<OP, T, VType, D, I, true>& in) {
-    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
+  combine(Reducer<OP, T, I, VType>& out, const Reducer<OP, T, I, VType>& in) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    out.valop_m.val = OP<VT,VT,VT>{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
+  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType, D, I, true>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
-    *red.passthruval = red.valop_m.val.val;
-    *red.passthruindex = red.valop_m.val.loc;
-  }
-
-  // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType, D, I, false>& red) {
-    red.valop_m.val = OP<T,T,T>::identity();
-  }
-
-  // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType, D, I, false>& out, const Reducer<OP, T, VType, D, I, false>& in) {
-    out.valop_m.val = OP<T,T,T>{}(out.valop_m.val, in.valop_m.val);
-  }
-
-  // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename D, typename I, typename VType>
-  camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType, D, I, false>& red) {
-    *red.target = OP<T,T,T>{}(*red.target, red.valop_m.val);
+  resolve(Reducer<OP, T, I, VType>& red) {
+    using VT = typename Reducer<OP, T, I, VType>::value_type;
+    red.set(OP<VT,VT,VT>{}(*red.target, red.valop_m.val));
   }
 
 #endif

From d0b370f8c82b57787cc2297c3b9136fed5ff91c4 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 26 Sep 2024 17:08:35 -0700
Subject: [PATCH 68/82] Split loc tests to hopefully reduce CI build times.

---
 .../forall/reduce-basic/CMakeLists.txt        |   2 +-
 .../test-forall-basic-expt-ReduceMaxLoc.hpp   |  43 ----
 ...test-forall-basic-expt-ReduceMaxLocAlt.hpp | 199 ++++++++++++++++++
 .../test-forall-basic-expt-ReduceMinLoc.hpp   |  43 ----
 ...test-forall-basic-expt-ReduceMinLocAlt.hpp | 198 +++++++++++++++++
 5 files changed, 398 insertions(+), 87 deletions(-)
 create mode 100644 test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLocAlt.hpp
 create mode 100644 test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLocAlt.hpp

diff --git a/test/functional/forall/reduce-basic/CMakeLists.txt b/test/functional/forall/reduce-basic/CMakeLists.txt
index 42f03f04c8..de6ce12264 100644
--- a/test/functional/forall/reduce-basic/CMakeLists.txt
+++ b/test/functional/forall/reduce-basic/CMakeLists.txt
@@ -8,7 +8,7 @@
 #
 # List of experimental reduction types for generating test files.
 #
-set(REDUCETYPES ReduceSum ReduceMin ReduceMax ReduceMaxLoc ReduceMinLoc)
+set(REDUCETYPES ReduceSum ReduceMin ReduceMax ReduceMaxLoc ReduceMinLoc ReduceMaxLocAlt ReduceMinLocAlt)
 
 set(DATATYPES CoreReductionDataTypeList)
 
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
index 827202dacf..225018eac8 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
@@ -88,49 +88,6 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
-  
-  factor = 3;
-  RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
-      m.maxloc( working_array[idx] * factor, idx);
-  });
-  ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
-  ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
-
-  VL_TYPE max2(max_init, maxloc_init);
-
-  RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&max2),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
-      m2.max( max );
-  });
-  ASSERT_EQ(static_cast<DATA_TYPE>(max2.getVal()), static_cast<DATA_TYPE>(max.getVal()));
-  ASSERT_EQ(static_cast<IDX_TYPE>(max2.getLoc()), static_cast<IDX_TYPE>(max.getLoc()));
-
-  DATA_TYPE s_max = max_init;
-  IDX_TYPE s_maxloc = maxloc_init;
-
-  factor = 4;
-  RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max, &s_maxloc),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
-      m.maxloc( working_array[idx] * factor, idx);
-  });
-  ASSERT_EQ(static_cast<DATA_TYPE>(s_max), ref_max * factor);
-  ASSERT_EQ(static_cast<IDX_TYPE>(s_maxloc), ref_maxloc);
-
-  DATA_TYPE s_max2 = max_init;
-  IDX_TYPE s_maxloc2 = maxloc_init;
-
-  RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max2, &s_maxloc2),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
-      m2.max(max2);
-  });
-  ASSERT_EQ(static_cast<DATA_TYPE>(s_max2), static_cast<DATA_TYPE>(max2.getVal()));
-  ASSERT_EQ(static_cast<IDX_TYPE>(s_maxloc2), static_cast<IDX_TYPE>(max2.getLoc()));
-
 
   deallocateForallTestData<DATA_TYPE>(working_res,
                                       working_array,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLocAlt.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLocAlt.hpp
new file mode 100644
index 0000000000..68810ac893
--- /dev/null
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLocAlt.hpp
@@ -0,0 +1,199 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+// Copyright (c) 2016-24, Lawrence Livermore National Security, LLC
+// and RAJA project contributors. See the RAJA/LICENSE file for details.
+//
+// SPDX-License-Identifier: (BSD-3-Clause)
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+
+#ifndef __TEST_FORALL_BASIC_REDUCEMAXLOCALT_HPP__
+#define __TEST_FORALL_BASIC_REDUCEMAXLOCALT_HPP__
+
+#include <cstdlib>
+#include <ctime>
+#include <numeric>
+#include <vector>
+
+template <typename IDX_TYPE, typename DATA_TYPE,
+          typename SEG_TYPE,
+          typename EXEC_POLICY, typename REDUCE_POLICY>
+void ForallReduceMaxLocAltBasicTestImpl(const SEG_TYPE& seg,
+                                     const std::vector<IDX_TYPE>& seg_idx,
+                                     camp::resources::Resource working_res)
+{
+  IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
+  IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
+
+  DATA_TYPE* working_array;
+  DATA_TYPE* check_array;
+  DATA_TYPE* test_array;
+
+  allocateForallTestData<DATA_TYPE>(data_len,
+                                    working_res,
+                                    &working_array,
+                                    &check_array,
+                                    &test_array);
+
+  const int modval = 100;
+  const DATA_TYPE max_init = -modval;
+  const IDX_TYPE maxloc_init = -1;
+  const IDX_TYPE maxloc_idx = seg_idx[ idx_len * 2/3 ];
+  const DATA_TYPE big_max = modval*10;
+  const IDX_TYPE big_maxloc = maxloc_init;
+
+  for (IDX_TYPE i = 0; i < data_len; ++i) {
+    test_array[i] = static_cast<DATA_TYPE>( 1000 % modval );
+  }
+  test_array[maxloc_idx] = static_cast<DATA_TYPE>(big_max);
+
+  DATA_TYPE ref_max = max_init;
+  IDX_TYPE ref_maxloc = maxloc_init;
+  for (IDX_TYPE i = 0; i < idx_len; ++i) {
+    if ( test_array[ seg_idx[i] ] > ref_max ) {
+       ref_max = test_array[ seg_idx[i] ];
+       ref_maxloc = seg_idx[i];
+    } 
+  }
+
+  working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
+
+
+  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE, IDX_TYPE>;
+  using VL_LAMBDA_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::maximum>;
+  VL_TYPE maxinit(big_max, maxloc_init);
+  VL_TYPE max(max_init, maxloc_init);
+
+  RAJA::forall<EXEC_POLICY>(seg, 
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&maxinit),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
+    RAJA::expt::KernelName("RAJA Reduce MaxLoc"),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &mi, VL_LAMBDA_TYPE &m) {
+      mi.maxloc( working_array[idx], idx );
+      m.maxloc( working_array[idx], idx );
+  });
+
+  ASSERT_EQ(static_cast<DATA_TYPE>(maxinit.getVal()), big_max);
+  ASSERT_EQ(static_cast<IDX_TYPE>(maxinit.getLoc()), big_maxloc);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max);
+  ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
+
+  VL_TYPE max2(max_init, maxloc_init);
+
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
+      m2.max( max );
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(max2.getVal()), static_cast<DATA_TYPE>(max.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(max2.getLoc()), static_cast<IDX_TYPE>(max.getLoc()));
+
+  DATA_TYPE s_max = max_init;
+  IDX_TYPE s_maxloc = maxloc_init;
+
+  const int factor = 4;
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max, &s_maxloc),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
+      m.maxloc( working_array[idx] * factor, idx);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_max), ref_max * factor);
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_maxloc), ref_maxloc);
+
+  DATA_TYPE s_max2 = max_init;
+  IDX_TYPE s_maxloc2 = maxloc_init;
+
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max2, &s_maxloc2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
+      m2.max(max2);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_max2), static_cast<DATA_TYPE>(max2.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_maxloc2), static_cast<IDX_TYPE>(max2.getLoc()));
+
+
+  deallocateForallTestData<DATA_TYPE>(working_res,
+                                      working_array,
+                                      check_array,
+                                      test_array);
+}
+
+TYPED_TEST_SUITE_P(ForallReduceMaxLocAltBasicTest);
+template <typename T>
+class ForallReduceMaxLocAltBasicTest : public ::testing::Test
+{
+};
+
+TYPED_TEST_P(ForallReduceMaxLocAltBasicTest, ReduceMaxLocAltBasicForall)
+{
+  using IDX_TYPE      = typename camp::at<TypeParam, camp::num<0>>::type;
+  using DATA_TYPE     = typename camp::at<TypeParam, camp::num<1>>::type;
+  using WORKING_RES   = typename camp::at<TypeParam, camp::num<2>>::type;
+  using EXEC_POLICY   = typename camp::at<TypeParam, camp::num<3>>::type;
+  using REDUCE_POLICY = typename camp::at<TypeParam, camp::num<4>>::type;
+
+  camp::resources::Resource working_res{WORKING_RES::get_default()};
+
+  std::vector<IDX_TYPE> seg_idx;
+
+// Range segment tests
+  RAJA::TypedRangeSegment<IDX_TYPE> r1( 0, 28 );
+  RAJA::getIndices(seg_idx, r1);
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r1, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeSegment<IDX_TYPE> r2( 3, 642 );
+  RAJA::getIndices(seg_idx, r2);
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r2, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeSegment<IDX_TYPE> r3( 0, 2057 );
+  RAJA::getIndices(seg_idx, r3);
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r3, seg_idx, working_res);
+
+// Range-stride segment tests
+  seg_idx.clear();
+  RAJA::TypedRangeStrideSegment<IDX_TYPE> r4( 0, 188, 2 );
+  RAJA::getIndices(seg_idx, r4);
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeStrideSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r4, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeStrideSegment<IDX_TYPE> r5( 3, 1029, 3 );
+  RAJA::getIndices(seg_idx, r5);
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeStrideSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r5, seg_idx, working_res);
+
+// List segment tests
+  seg_idx.clear();
+  IDX_TYPE last = 10567;
+  srand( time(NULL) );
+  for (IDX_TYPE i = 0; i < last; ++i) {
+    IDX_TYPE randval = IDX_TYPE( rand() % RAJA::stripIndexType(last) );
+    if ( i < randval ) {
+      seg_idx.push_back(i);
+    }
+  }
+  RAJA::TypedListSegment<IDX_TYPE> l1( &seg_idx[0], seg_idx.size(),
+                                       working_res );
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedListSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    l1, seg_idx, working_res);
+}
+
+REGISTER_TYPED_TEST_SUITE_P(ForallReduceMaxLocAltBasicTest,
+                            ReduceMaxLocAltBasicForall);
+
+#endif  // __TEST_FORALL_BASIC_REDUCEMAXLOCALT_HPP__
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
index efe67c0f64..dc48b403ea 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
@@ -88,49 +88,6 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
 
-  factor = 3;
-  RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
-      m.minloc( working_array[idx] * factor, idx);
-  });
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
-  ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
-
-  VL_TYPE min2(min_init, minloc_init);
-
-  RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&min2),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
-      m2.min( min );
-  });
-  ASSERT_EQ(static_cast<DATA_TYPE>(min2.getVal()), static_cast<DATA_TYPE>(min.getVal()));
-  ASSERT_EQ(static_cast<IDX_TYPE>(min2.getLoc()), static_cast<IDX_TYPE>(min.getLoc()));
-
-  DATA_TYPE s_min = min_init;
-  IDX_TYPE s_minloc = minloc_init;
-
-  factor = 4;
-  RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min, &s_minloc),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
-      m.minloc( working_array[idx] * factor, idx);
-  });
-  ASSERT_EQ(static_cast<DATA_TYPE>(s_min), ref_min * factor);
-  ASSERT_EQ(static_cast<IDX_TYPE>(s_minloc), ref_minloc);
-
-  DATA_TYPE s_min2 = min_init;
-  IDX_TYPE s_minloc2 = minloc_init;
-
-  RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min2, &s_minloc2),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
-      m2.min(min2);
-  });
-  ASSERT_EQ(static_cast<DATA_TYPE>(s_min2), static_cast<DATA_TYPE>(min2.getVal()));
-  ASSERT_EQ(static_cast<IDX_TYPE>(s_minloc2), static_cast<IDX_TYPE>(min2.getLoc()));
-   
-
   deallocateForallTestData<DATA_TYPE>(working_res,
                                       working_array,
                                       check_array,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLocAlt.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLocAlt.hpp
new file mode 100644
index 0000000000..07a6058234
--- /dev/null
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLocAlt.hpp
@@ -0,0 +1,198 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+// Copyright (c) 2016-24, Lawrence Livermore National Security, LLC
+// and RAJA project contributors. See the RAJA/LICENSE file for details.
+//
+// SPDX-License-Identifier: (BSD-3-Clause)
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+
+#ifndef __TEST_FORALL_BASIC_REDUCEMINLOCALT_HPP__
+#define __TEST_FORALL_BASIC_REDUCEMINLOCALT_HPP__
+
+#include <cstdlib>
+#include <ctime>
+#include <numeric>
+#include <vector>
+
+template <typename IDX_TYPE, typename DATA_TYPE,
+          typename SEG_TYPE,
+          typename EXEC_POLICY, typename REDUCE_POLICY>
+void ForallReduceMinLocAltBasicTestImpl(const SEG_TYPE& seg,
+                                     const std::vector<IDX_TYPE>& seg_idx,
+                                     camp::resources::Resource working_res)
+{
+  IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
+  IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
+
+  DATA_TYPE* working_array;
+  DATA_TYPE* check_array;
+  DATA_TYPE* test_array;
+
+  allocateForallTestData<DATA_TYPE>(data_len,
+                                    working_res,
+                                    &working_array,
+                                    &check_array,
+                                    &test_array);
+
+  const int modval = 100;
+  const DATA_TYPE min_init = modval+1;
+  const IDX_TYPE minloc_init = -1;
+  const IDX_TYPE minloc_idx = seg_idx[ idx_len * 2/3 ];
+  const DATA_TYPE small_min = -modval;
+  const IDX_TYPE small_minloc = minloc_init;
+
+  for (IDX_TYPE i = 0; i < data_len; ++i) {
+    test_array[i] = static_cast<DATA_TYPE>( rand() % modval );
+  }
+  test_array[minloc_idx] = static_cast<DATA_TYPE>(small_min);
+
+  DATA_TYPE ref_min = min_init;
+  IDX_TYPE ref_minloc = minloc_init;
+  for (IDX_TYPE i = 0; i < idx_len; ++i) {
+    if ( test_array[ seg_idx[i] ] < ref_min ) {
+       ref_min = test_array[ seg_idx[i] ];
+       ref_minloc = seg_idx[i];
+    } 
+  }
+
+  working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
+
+  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE, IDX_TYPE>;
+  using VL_LAMBDA_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::minimum>;
+  VL_TYPE mininit(small_min, minloc_init);
+  VL_TYPE min(min_init, minloc_init);
+
+  RAJA::forall<EXEC_POLICY>(seg, 
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
+    RAJA::expt::KernelName("RAJA Reduce MinLoc"),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &mi, VL_LAMBDA_TYPE &m) {
+      mi.minloc( working_array[idx], idx );
+      m.minloc( working_array[idx], idx );
+  });
+
+  ASSERT_EQ(static_cast<DATA_TYPE>(mininit.getVal()), small_min);
+  ASSERT_EQ(static_cast<IDX_TYPE>(mininit.getLoc()), small_minloc);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min);
+  ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
+
+  VL_TYPE min2(min_init, minloc_init);
+
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
+      m2.min( min );
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(min2.getVal()), static_cast<DATA_TYPE>(min.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(min2.getLoc()), static_cast<IDX_TYPE>(min.getLoc()));
+
+  DATA_TYPE s_min = min_init;
+  IDX_TYPE s_minloc = minloc_init;
+
+  const int factor = 4;
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min, &s_minloc),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
+      m.minloc( working_array[idx] * factor, idx);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_min), ref_min * factor);
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_minloc), ref_minloc);
+
+  DATA_TYPE s_min2 = min_init;
+  IDX_TYPE s_minloc2 = minloc_init;
+
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min2, &s_minloc2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
+      m2.min(min2);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_min2), static_cast<DATA_TYPE>(min2.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_minloc2), static_cast<IDX_TYPE>(min2.getLoc()));
+   
+
+  deallocateForallTestData<DATA_TYPE>(working_res,
+                                      working_array,
+                                      check_array,
+                                      test_array);
+}
+
+TYPED_TEST_SUITE_P(ForallReduceMinLocAltBasicTest);
+template <typename T>
+class ForallReduceMinLocAltBasicTest : public ::testing::Test
+{
+};
+
+TYPED_TEST_P(ForallReduceMinLocAltBasicTest, ReduceMinLocAltBasicForall)
+{
+  using IDX_TYPE      = typename camp::at<TypeParam, camp::num<0>>::type;
+  using DATA_TYPE     = typename camp::at<TypeParam, camp::num<1>>::type;
+  using WORKING_RES   = typename camp::at<TypeParam, camp::num<2>>::type;
+  using EXEC_POLICY   = typename camp::at<TypeParam, camp::num<3>>::type;
+  using REDUCE_POLICY = typename camp::at<TypeParam, camp::num<4>>::type;
+
+  camp::resources::Resource working_res{WORKING_RES::get_default()};
+
+  std::vector<IDX_TYPE> seg_idx;
+
+// Range segment tests
+  RAJA::TypedRangeSegment<IDX_TYPE> r1( 0, 28 );
+  RAJA::getIndices(seg_idx, r1);
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r1, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeSegment<IDX_TYPE> r2( 3, 642 );
+  RAJA::getIndices(seg_idx, r2);
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r2, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeSegment<IDX_TYPE> r3( 0, 2057 );
+  RAJA::getIndices(seg_idx, r3);
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r3, seg_idx, working_res);
+
+// Range-stride segment tests
+  seg_idx.clear();
+  RAJA::TypedRangeStrideSegment<IDX_TYPE> r4( 0, 188, 2 );
+  RAJA::getIndices(seg_idx, r4);
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeStrideSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r4, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeStrideSegment<IDX_TYPE> r5( 3, 1029, 3 );
+  RAJA::getIndices(seg_idx, r5);
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeStrideSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r5, seg_idx, working_res);
+
+// List segment tests
+  seg_idx.clear();
+  IDX_TYPE last = 10567;
+  srand( time(NULL) );
+  for (IDX_TYPE i = 0; i < last; ++i) {
+    IDX_TYPE randval = IDX_TYPE( rand() % RAJA::stripIndexType(last) );
+    if ( i < randval ) {
+      seg_idx.push_back(i);
+    }
+  }
+  RAJA::TypedListSegment<IDX_TYPE> l1( &seg_idx[0], seg_idx.size(),
+                                       working_res );
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedListSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    l1, seg_idx, working_res);
+}
+
+REGISTER_TYPED_TEST_SUITE_P(ForallReduceMinLocAltBasicTest,
+                            ReduceMinLocAltBasicForall);
+
+#endif  // __TEST_FORALL_BASIC_REDUCEMINLOCALT_HPP__

From c4ddb9ec752c15c2b47ca932d6ef561f42f315c8 Mon Sep 17 00:00:00 2001
From: Arturo Vargas <vargas45@llnl.gov>
Date: Thu, 26 Sep 2024 18:08:30 -0700
Subject: [PATCH 69/82] clean up pass, add other variants

---
 benchmark/CMakeLists.txt     |  9 ++--
 benchmark/raja_view_blur.cpp | 82 ++++++++++++++++++++++++++++--------
 2 files changed, 70 insertions(+), 21 deletions(-)

diff --git a/benchmark/CMakeLists.txt b/benchmark/CMakeLists.txt
index 82f3e10b13..143d6b5b98 100644
--- a/benchmark/CMakeLists.txt
+++ b/benchmark/CMakeLists.txt
@@ -17,10 +17,11 @@ raja_add_benchmark(
   SOURCES benchmark-atomic.cpp)
 endif()
 
-raja_add_benchmark(
-  NAME ltimes
-  SOURCES ltimes.cpp)
+#TODO: Fix build issues
+#raja_add_benchmark(
+#  NAME ltimes
+#  SOURCES ltimes.cpp)
 
-raja_add_bench_mark(
+raja_add_benchmark(
   NAME raja_view_blur
   SOURCES raja_view_blur.cpp)
diff --git a/benchmark/raja_view_blur.cpp b/benchmark/raja_view_blur.cpp
index c3db04b2dd..331d6c51dd 100644
--- a/benchmark/raja_view_blur.cpp
+++ b/benchmark/raja_view_blur.cpp
@@ -15,7 +15,19 @@
  *
  */
 
-#if defined(RAJA_ENABLE_HIP)
+//Uncomment to specify variant
+//#define RUN_HIP_VARIANT
+//#define RUN_CUDA_VARIANT
+//#define RUN_SYCL_VARIANT
+//#define RUN_OPENMP_VARIANT
+#define RUN_SEQ_VARIANT
+
+
+using host_pol = RAJA::seq_exec;
+using host_resources = RAJA::resources::Host;
+
+
+#if defined(RAJA_ENABLE_HIP) && defined(RUN_HIP_VARIANT)
 using device_pol = RAJA::hip_exec<256>;
 using device_resources = RAJA::resource::Hip;
 
@@ -28,7 +40,9 @@ using kernel_pol = RAJA::KernelPolicy<
     >
    >
   >;
-#elif defined(RAJA_ENABLE_CUDA)
+#endif
+
+#if defined(RAJA_ENABLE_CUDA) && defined(RUN_CUDA_VARIANT)
 using device_pol = RAJA::cuda_exec<256>;
 using device_resources = RAJA::resources::Cuda;
 
@@ -41,33 +55,68 @@ using kernel_pol = RAJA::KernelPolicy<
     >
    >
   >;
-#else
-using host_pol = RAJA::seq_exec;
+#endif
+
+#if defined(RAJA_ENABLE_SYCL) && defined(RUN_SYCL_VARIANT)
+using device_pol = RAJA::sycl_exec<256>;
+using device_resources = RAJA::resources::Sycl;
+
+using kernel_pol = RAJA::KernelPolicy<
+  RAJA::statement::SyclKernel<
+    RAJA::statement::For<1, RAJA::sycl_global_item_1,
+      RAJA::statement::For<0, RAJA::sycl_global_item_2,
+         RAJA::statement::Lambda<0>
+      >
+    >
+   >
+  >;
+#endif
+
+#if defined(RAJA_ENABLE_OPENMP) && defined(RUN_OPENMP_VARIANT)
+using device_pol = RAJA::omp_parallel_for_exec;
 using device_resources = RAJA::resources::Host;
+
+using kernel_pol = RAJA::KernelPolicy<
+    RAJA::statement::For<1, RAJA::omp_parallel_for_exec,
+      RAJA::statement::For<0, RAJA::seq_exec,
+         RAJA::statement::Lambda<0>
+      >
+    >
+  >;
 #endif
 
-using host_resources = RAJA::resources::Host;
+#if defined(RUN_SEQ_VARIANT)
+using device_pol = RAJA::seq_exec;
+using device_resources =  RAJA::resources::Host;
+
+using kernel_pol = RAJA::KernelPolicy<
+    RAJA::statement::For<1, RAJA::seq_exec,
+      RAJA::statement::For<0, RAJA::seq_exec,
+         RAJA::statement::Lambda<0>
+      >
+    >
+  >;
+#endif
 
 int main(int RAJA_UNUSED_ARG(argc), char **RAJA_UNUSED_ARG(argv[]))
 {
 
   const int N = 10000;
   const int K = 17;
-  
+
   device_resources def_device_res{device_resources::get_default()};
   host_resources   def_host_res{host_resources::get_default()};
-  
+
   auto timer = RAJA::Timer();
-  
+
   //launch to intialize the stream
   RAJA::forall<device_pol>
-    (RAJA::RangeSegment(0,1), [=] RAJA_DEVICE (int i) {
-      printf(" \n");
+    (RAJA::RangeSegment(0,1), [=] RAJA_HOST_DEVICE (int i) {
   });
 
   int * array      = def_host_res.allocate<int>(N * N);
   int * array_copy = def_host_res.allocate<int>(N * N);
-  
+
   //big array, or image
   for (int i = 0; i < N * N; ++i) {
     array[i] = 1;
@@ -75,7 +124,6 @@ int main(int RAJA_UNUSED_ARG(argc), char **RAJA_UNUSED_ARG(argv[]))
   }
 
   //small array that acts as the blur
-  //int* kernel = new int[K * K];
   int * kernel  = def_host_res.allocate<int>(K * K);
   for (int i = 0; i < K * K; ++i) {
     kernel[i] = 2;
@@ -102,7 +150,7 @@ int main(int RAJA_UNUSED_ARG(argc), char **RAJA_UNUSED_ARG(argv[]))
 
   RAJA::kernel<kernel_pol>
     (RAJA::make_tuple(range_i, range_j),
-     [=] RAJA_DEVICE (int i, int j) {
+     [=] RAJA_HOST_DEVICE (int i, int j) {
       int sum = 0;
 
       //looping through the "blur"
@@ -129,10 +177,10 @@ int main(int RAJA_UNUSED_ARG(argc), char **RAJA_UNUSED_ARG(argv[]))
 
  timer.reset();
  timer.start();
- 
+
   RAJA::kernel<kernel_pol>
     (RAJA::make_tuple(range_i, range_j),
-     [=] RAJA_DEVICE (int i, int j) {
+     [=] RAJA_HOST_DEVICE (int i, int j) {
       int sum = 0;
 
       // looping through the "blur"
@@ -161,10 +209,10 @@ int main(int RAJA_UNUSED_ARG(argc), char **RAJA_UNUSED_ARG(argv[]))
   def_device_res.deallocate(d_array);
   def_device_res.deallocate(d_array_copy);
   def_device_res.deallocate(d_kernel);
-    
+
   def_host_res.deallocate(array);
   def_host_res.deallocate(array_copy);
   def_host_res.deallocate(kernel);
-  
+
   return 0;
 }

From 29b9332873a60d07eed867a3d3f760dc89ae7abd Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 27 Sep 2024 10:14:36 -0700
Subject: [PATCH 70/82] User documentation.

---
 docs/sphinx/user_guide/feature/reduction.rst | 52 ++++++++++++--------
 1 file changed, 32 insertions(+), 20 deletions(-)

diff --git a/docs/sphinx/user_guide/feature/reduction.rst b/docs/sphinx/user_guide/feature/reduction.rst
index 5d6b9b58ef..130f23a504 100644
--- a/docs/sphinx/user_guide/feature/reduction.rst
+++ b/docs/sphinx/user_guide/feature/reduction.rst
@@ -240,11 +240,15 @@ RAJA::expt::Reduce
           compatible with the ``EXEC_POL``. ``Seg`` is the iteration space
           object for ``RAJA::forall``.
 
-.. important:: The order of the local reduction variables in the
-               kernel body lambda expression must ``RAJA::expt::ValOp`` objects which
-               match exactly in the underlying reduction data type, and RAJA
-               operator, with the corresponding ``RAJA::expt::Reduce`` arguments
-               to the ``RAJA::forall`` to ensure that the correct result is obtained.
+.. important:: The local reduction arguments to the lambda expression must be
+               ``RAJA::expt::ValOp`` references. Each ``ValOp`` references
+               corresponds to a ``RAJA::expt::Reduce`` call within the forall
+               arguments. The ``ValOp`` reduction data type and RAJA operator need
+               to match the data type referenced and operator template argument
+               in the ``RAJA::expt::Reduce`` call. Finally, the ordering of the
+               ``ValOp`` references must correspond to the ordering of the
+               ``RAJA::expt::Reduce`` calls to ensure that the correct result is
+               obtained.
 
 RAJA::expt::ValLoc
 ..................
@@ -258,7 +262,7 @@ methods to access the reduction results.
 
 In the kernel body lambda expression, a ``ValLoc<T,I>`` must be wrapped in a
 ``ValOp``, and passed to the lambda in the same order as the corresponding 
-``RAJA::expt::Reduce`` arguments, e.g. ``ValOp<ValLoc<T,I>, minimum>``.
+``RAJA::expt::Reduce`` arguments, e.g. ``ValOp<ValLoc<T,I>, Op>``.
 For convenience, the alias of ``RAJA::expt::ValLocOp<T,I,Op>`` can be used.
 Within the lambda, this ``ValLocOp`` object provides ``minloc``, and ``maxloc``
 functions::
@@ -266,34 +270,42 @@ functions::
   double* a = ...;
 
   using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValOp<ValLoc<double, RAJA::Index_type>,
-                                                       RAJA::expt::minimum>;
+                                                       RAJA::operators::minimum>;
+  using VALOPLOC_DOUBLE_MAX = RAJA::expt::ValOpLoc<double, RAJA::Index_type,
+                                                   RAJA::operators::minimum>;
 
   using VL_DOUBLE = RAJA::expt::ValLoc<double>;
-  VL_DOUBLE rm_loc;
+  VL_DOUBLE rmin_loc;
+  VL_DOUBLE rmax_loc;
 
   RAJA::forall<EXEC_POL> ( Res, Seg,
-  RAJA::expt::Reduce<RAJA::operators::minimum>(&rm_loc),
-  [=] (int i, VALOPLOC_DOUBLE_MIN& _rm_loc) {
-    _rm_loc.minloc(a[i], i);
+  RAJA::expt::Reduce<RAJA::operators::minimum>(&rmin_loc),
+  RAJA::expt::Reduce<RAJA::operators::maximum>(&rmax_loc),
+  [=] (int i, VALOPLOC_DOUBLE_MIN& _rmin_loc, VALOPLOC_DOUBLE_MAX& _rmax_loc) {
+    _rmin_loc.minloc(a[i], i);
+    _rmax_loc.minloc(a[i], i);
   }
   );
 
-  std::cout << rm_loc.getVal() ...
-  std::cout << rm_loc.getLoc() ...
+  std::cout << rmin_loc.getVal() ...
+  std::cout << rmin_loc.getLoc() ...
+  std::cout << rmax_loc.getVal() ...
+  std::cout << rmax_loc.getLoc() ...
 
 Alternatively, *loc* reductions can be performed on separate reduction data, and
-location variables without a ``ValLoc``. The change required is to pass
-a ``RAJA::expt::ReduceLoc`` argument to the forall, templated on the reduction
-operation, and passing in references to the data and location in that respective
-order. The data and location can be accessed outside for the forall directly
-without ``getVal()`` or ``getLoc()`` functions.
+location variables without a ``ValLoc`` object. To use this capability, a
+``RAJA::expt::ReduceLoc`` call must be passed to the ``RAJA::forall``, templated on
+the reduction operation, and passing in references to the data and location as
+``ReduceLoc`` function arguments. The data and location can be accessed outside of
+the forall directly without ``getVal()`` or ``getLoc()`` functions.
 :: 
 
   double* a = ...;
 
-  using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValOp<ValLoc<double, RAJA::Index_type>,
-                                                       RAJA::expt::minimum>;
+  using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValOpLoc<double, RAJA::Index_type,
+                                                   RAJA::operators::minimum>;
 
+  // No ValLoc needed from the user here.
   double rm;
   RAJA::Index_type loc;
 

From 54bca5f7ecde552617b2a907562aca2f9359867e Mon Sep 17 00:00:00 2001
From: Rich Hornung <hornung1@llnl.gov>
Date: Fri, 27 Sep 2024 10:23:18 -0700
Subject: [PATCH 71/82] Fix Cmake version

---
 scripts/lc-builds/corona_sycl.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/lc-builds/corona_sycl.sh b/scripts/lc-builds/corona_sycl.sh
index c343c4a3e8..4828d7dce4 100755
--- a/scripts/lc-builds/corona_sycl.sh
+++ b/scripts/lc-builds/corona_sycl.sh
@@ -38,7 +38,7 @@ DATE=$(printf '%(%Y-%m-%d)T\n' -1)
 export PATH=${SYCL_PATH}/bin:$PATH
 export LD_LIBRARY_PATH=${SYCL_PATH}/lib:${SYCL_PATH}/lib64:$LD_LIBRARY_PATH
 
-module load cmake/3.24.2
+module load cmake/3.23.1
 
 cmake \
   -DCMAKE_BUILD_TYPE=${BUILD_TYPE} \

From 4b7034db453affc2cfb1f166db2935a16e8a6d2c Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 27 Sep 2024 10:34:11 -0700
Subject: [PATCH 72/82] Formatting in example.

---
 examples/forall-param-reductions.cpp | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/examples/forall-param-reductions.cpp b/examples/forall-param-reductions.cpp
index 88c526cfe7..2305f74c2b 100644
--- a/examples/forall-param-reductions.cpp
+++ b/examples/forall-param-reductions.cpp
@@ -274,13 +274,13 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&omp_t_max2, &omp_t_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce Target OpenMP Kernel"),
     [=](int i,
-				VALOP_INT_SUM &_omp_t_sum,
-				VALOP_INT_MIN &_omp_t_min,
-				VALOP_INT_MAX &_omp_t_max,
-				VALOPLOC_INT_MIN &_omp_t_minloc,
-				VALOPLOC_INT_MAX &_omp_t_maxloc,
-				VALOPLOC_INT_MIN &_omp_t_minloc2,
-				VALOPLOC_INT_MAX &_omp_t_maxloc2) {
+        VALOP_INT_SUM &_omp_t_sum,
+        VALOP_INT_MIN &_omp_t_min,
+        VALOP_INT_MAX &_omp_t_max,
+        VALOPLOC_INT_MIN &_omp_t_minloc,
+        VALOPLOC_INT_MAX &_omp_t_maxloc,
+        VALOPLOC_INT_MIN &_omp_t_minloc2,
+        VALOPLOC_INT_MAX &_omp_t_maxloc2) {
       _omp_t_sum += a[i];
 
       _omp_t_min.min(a[i]);
@@ -483,13 +483,13 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&sycl_max2, &sycl_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce SYCL Kernel"),
     [=] RAJA_DEVICE ( int i,
-				              VALOP_INT_SUM &_sycl_sum,
-				              VALOP_INT_MIN &_sycl_min,
-				              VALOP_INT_MAX &_sycl_max,
-				              VALOPLOC_INT_MIN &_sycl_minloc,
-				              VALOPLOC_INT_MAX &_sycl_maxloc,
-				              VALOPLOC_INT_MIN &_sycl_minloc2,
-				              VALOPLOC_INT_MAX &_sycl_maxloc2) {
+                      VALOP_INT_SUM &_sycl_sum,
+                      VALOP_INT_MIN &_sycl_min,
+                      VALOP_INT_MAX &_sycl_max,
+                      VALOPLOC_INT_MIN &_sycl_minloc,
+                      VALOPLOC_INT_MAX &_sycl_maxloc,
+                      VALOPLOC_INT_MIN &_sycl_minloc2,
+                      VALOPLOC_INT_MAX &_sycl_maxloc2) {
       _sycl_sum += d_a[i];
 
       _sycl_min.min(d_a[i]);

From 01fab6a5f14c80e1256ddbf77fb61498c6199246 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 27 Sep 2024 10:34:27 -0700
Subject: [PATCH 73/82] Reword.

---
 docs/sphinx/user_guide/feature/reduction.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/docs/sphinx/user_guide/feature/reduction.rst b/docs/sphinx/user_guide/feature/reduction.rst
index 130f23a504..9d9f64e5fe 100644
--- a/docs/sphinx/user_guide/feature/reduction.rst
+++ b/docs/sphinx/user_guide/feature/reduction.rst
@@ -263,7 +263,7 @@ methods to access the reduction results.
 In the kernel body lambda expression, a ``ValLoc<T,I>`` must be wrapped in a
 ``ValOp``, and passed to the lambda in the same order as the corresponding 
 ``RAJA::expt::Reduce`` arguments, e.g. ``ValOp<ValLoc<T,I>, Op>``.
-For convenience, the alias of ``RAJA::expt::ValLocOp<T,I,Op>`` can be used.
+For convenience, an alias of ``RAJA::expt::ValLocOp<T,I,Op>`` is provided.
 Within the lambda, this ``ValLocOp`` object provides ``minloc``, and ``maxloc``
 functions::
 
@@ -271,7 +271,7 @@ functions::
 
   using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValOp<ValLoc<double, RAJA::Index_type>,
                                                        RAJA::operators::minimum>;
-  using VALOPLOC_DOUBLE_MAX = RAJA::expt::ValOpLoc<double, RAJA::Index_type,
+  using VALOPLOC_DOUBLE_MAX = RAJA::expt::ValLocOp<double, RAJA::Index_type,
                                                    RAJA::operators::minimum>;
 
   using VL_DOUBLE = RAJA::expt::ValLoc<double>;
@@ -302,7 +302,7 @@ the forall directly without ``getVal()`` or ``getLoc()`` functions.
 
   double* a = ...;
 
-  using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValOpLoc<double, RAJA::Index_type,
+  using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValLocOp<double, RAJA::Index_type,
                                                    RAJA::operators::minimum>;
 
   // No ValLoc needed from the user here.

From 0a17938d5b1b9f2c3bab882c715a48df26aa50b8 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Wed, 2 Oct 2024 15:37:59 -0700
Subject: [PATCH 74/82] Various template simplifications.

---
 include/RAJA/pattern/params/reducer.hpp       | 41 +++++++++++--------
 include/RAJA/policy/cuda/params/reduce.hpp    | 22 ++++------
 include/RAJA/policy/cuda/reduce.hpp           | 18 ++++----
 include/RAJA/policy/hip/params/reduce.hpp     | 22 ++++------
 include/RAJA/policy/hip/reduce.hpp            | 18 ++++----
 include/RAJA/policy/openmp/params/reduce.hpp  | 21 ++++------
 .../policy/openmp_target/params/reduce.hpp    | 19 ++++-----
 .../RAJA/policy/sequential/params/reduce.hpp  | 21 ++++------
 include/RAJA/policy/sycl/params/reduce.hpp    | 21 ++++------
 9 files changed, 94 insertions(+), 109 deletions(-)

diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 9d25df692e..d5f1362040 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -60,9 +60,9 @@ namespace detail
   // T must be a basic data type
   // IndexType not used here
   // VType must be ValOp<T, Op>
-  template <template <typename, typename, typename> class Op, typename T, typename IndexType, typename VType>
+  template <typename Op, typename T, typename VType>
   struct Reducer : public ForallParamBase {
-    using op = Op<T,T,T>;
+    //using op = Op<T,T,T>;
     using value_type = T; // This is a basic data type
 
     Reducer() = default;
@@ -82,7 +82,7 @@ namespace detail
     value_type *target = nullptr;
 
     // Used in the resolve() call to set target in each backend
-    RAJA_HOST_DEVICE void set(value_type in) { *target = in; }
+    RAJA_HOST_DEVICE void setTarget(value_type in) { *target = in; }
 
     RAJA_HOST_DEVICE
     value_type &
@@ -104,13 +104,16 @@ namespace detail
   };
 
   // Partial specialization of Reducer for ValLoc
-  // T must be a basic data type
-  // VType must be ValOp<ValLoc<T,IndexType>,Op>
-  template <template <typename, typename, typename> class Op, typename T, typename IndexType>
-  struct Reducer<Op, T, IndexType, ValOp<ValLoc<T,IndexType>, Op>> : public ForallParamBase {
-    using value_type = ValLoc<T,IndexType>; // Note that this struct operates on ValLoc
-    using op = Op<value_type,value_type,value_type>;
-    using VType = ValOp<ValLoc<T,IndexType>, Op>;
+  // T must be a ValLoc
+  // TTOp is the template template version of Op, required by ValOp
+  // VType must be ValOp<ValLoc<>,Op>
+  template <typename Op, typename T, template <typename, typename, typename> class TTOp>
+  struct Reducer<Op, T, ValOp<ValLoc<typename T::value_type, typename T::index_type>, TTOp>> : public ForallParamBase {
+    using target_value_type = typename T::value_type; // This should be a basic data type extracted from the T=ValLoc passed in
+    using target_index_type = typename T::index_type;
+    using value_type = T; // Note that this struct operates on ValLoc
+    using op = TTOp<value_type,value_type,value_type>;
+    using VType = ValOp<ValLoc<target_value_type,target_index_type>, TTOp>;
 
     Reducer() = default;
 
@@ -120,7 +123,7 @@ namespace detail
 
     // Pass through constructor for ReduceLoc<>(data, index) case
     // The passthru variables point to vars defined by the user
-    RAJA_HOST_DEVICE Reducer(T *data_in, IndexType *index_in) : valop_m(VType(*data_in, *index_in)), target(&valop_m.val), passthruval(data_in), passthruindex(index_in) {}
+    RAJA_HOST_DEVICE Reducer(target_value_type *data_in, target_index_type *index_in) : valop_m(VType(*data_in, *index_in)), target(&valop_m.val), passthruval(data_in), passthruindex(index_in) {}
 
     Reducer(Reducer const &) = default;
     Reducer(Reducer &&) = default;
@@ -131,13 +134,13 @@ namespace detail
 
     value_type *target = nullptr;
 
-    T *passthruval = nullptr;
-    IndexType *passthruindex = nullptr;
+    target_value_type *passthruval = nullptr;
+    target_index_type *passthruindex = nullptr;
 
-    // This single-argument set() matches the basic data type Reducer::set()'s
+    // This single-argument setTarget() matches the basic data type Reducer::setTarget()'s
     // function signature to make the init/combine/resolve backend calls easier
     // to maintain, but operates on the passthru variables instead
-    RAJA_HOST_DEVICE void set(value_type in) { *passthruval = in.val; *passthruindex = in.loc; }
+    RAJA_HOST_DEVICE void setTarget(value_type in) { *passthruval = in.val; *passthruindex = in.loc; }
 
     RAJA_HOST_DEVICE
     value_type &
@@ -165,14 +168,15 @@ template <template <typename, typename, typename> class Op, typename T, typename
           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value> * = nullptr>
 auto constexpr Reduce(T *target)
 {
-  return detail::Reducer<Op, T, IndexType, ValOp<T, Op>>(target);
+  return detail::Reducer<Op<T,T,T>, T, ValOp<T, Op>>(target);
 }
 
 // User-defined ValLoc case.
 template <template <typename, typename, typename> class Op, typename T, typename IndexType>
 auto constexpr Reduce(ValLoc<T, IndexType> *target)
 {
-  return detail::Reducer<Op, T, IndexType, ValOp<ValLoc<T, IndexType>, Op>>(target);
+  using VL = ValLoc<T,IndexType>;
+  return detail::Reducer<Op<VL,VL,VL>, VL, ValOp<ValLoc<T, IndexType>, Op>>(target);
 }
 
 // Pass through use case where reduction value and location are separate, non-ValLoc types supplied by the user.
@@ -180,7 +184,8 @@ template <template <typename, typename, typename> class Op, typename T, typename
           std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value> * = nullptr>
 auto constexpr ReduceLoc(T *target, IndexType *index)
 {
-  return detail::Reducer<Op, T, IndexType, ValOp<ValLoc<T, IndexType>, Op>>(target, index);
+  using VL = ValLoc<T,IndexType>;
+  return detail::Reducer<Op<VL,VL,VL>, VL, ValOp<ValLoc<T, IndexType>, Op>>(target, index);
 }
 
 } // namespace expt
diff --git a/include/RAJA/policy/cuda/params/reduce.hpp b/include/RAJA/policy/cuda/params/reduce.hpp
index 1cfd6df535..7cf7ea984d 100644
--- a/include/RAJA/policy/cuda/params/reduce.hpp
+++ b/include/RAJA/policy/cuda/params/reduce.hpp
@@ -15,40 +15,36 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  init(Reducer<OP, T, I, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
+  init(Reducer<OP, T, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<VT>(1);
+    red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
     red.device_count = RAJA::cuda::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  combine(Reducer<OP, T, I, VType>& red)
+  combine(Reducer<OP, T, VType>& red)
   {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP, VT>(red.devicetarget,
+    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP>(red.devicetarget,
                                                                             red.getVal(),
                                                                             red.device_mem,
                                                                             red.device_count);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, I, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
+  resolve(Reducer<OP, T, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-
     // complete reduction
     ci.res.wait();
 
-    red.set(OP<VT,VT,VT>{}(*red.target, *red.devicetarget));
+    red.setTarget(OP{}(*red.target, *red.devicetarget));
 
     // free memory
     RAJA::cuda::device_zeroed_mempool_type::getInstance().free(red.device_count);
diff --git a/include/RAJA/policy/cuda/reduce.hpp b/include/RAJA/policy/cuda/reduce.hpp
index d55f1035a8..2b13417531 100644
--- a/include/RAJA/policy/cuda/reduce.hpp
+++ b/include/RAJA/policy/cuda/reduce.hpp
@@ -200,7 +200,7 @@ RAJA_DEVICE RAJA_INLINE int grid_reduce_last_block(T& val,
 
 namespace expt {
 
-template <typename ThreadIterationGetter, template <typename, typename, typename> class Combiner, typename T>
+template <typename ThreadIterationGetter, typename Combiner, typename T>
 RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 {
   const int numThreads = ThreadIterationGetter::size();
@@ -216,7 +216,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
     // reduce each warp
     for (int i = 1; i < RAJA::policy::cuda::device_constants.WARP_SIZE; i *= 2) {
       T rhs = RAJA::cuda::impl::shfl_xor_sync(temp, i);
-      temp = Combiner<T,T,T>{}(temp, rhs);
+      temp = Combiner{}(temp, rhs);
     }
 
   } else {
@@ -227,7 +227,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
       T rhs = RAJA::cuda::impl::shfl_sync(temp, srcLane);
       // only add from threads that exist (don't double count own value)
       if (srcLane < numThreads) {
-        temp = Combiner<T,T,T>{}(temp, rhs);
+        temp = Combiner{}(temp, rhs);
       }
     }
   }
@@ -263,7 +263,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 
       for (int i = 1; i < RAJA::policy::cuda::device_constants.MAX_WARPS; i *= 2) {
         T rhs = RAJA::cuda::impl::shfl_xor_sync(temp, i);
-        temp = Combiner<T,T,T>{}(temp, rhs);
+        temp = Combiner{}(temp, rhs);
       }
     }
 
@@ -274,7 +274,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 }
 
 
-template <typename GlobalIterationGetter, template <typename, typename, typename> class OP, typename T>
+template <typename GlobalIterationGetter, typename OP, typename T>
 RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
                                           T val,
                                           RAJA::detail::SoAPtr<T,RAJA::cuda::device_mempool_type> device_mem,
@@ -290,7 +290,7 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
   const int blockId = BlockIterationGetter::index();
   const int threadId = ThreadIterationGetter::index();
 
-  T temp = block_reduce<ThreadIterationGetter, OP>(val, OP<T,T,T>::identity());
+  T temp = block_reduce<ThreadIterationGetter, OP>(val, OP::identity());
 
   // one thread per block writes to device_mem
   bool lastBlock = false;
@@ -308,14 +308,14 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
 
   // last block accumulates values from device_mem
   if (lastBlock) {
-    temp = OP<T,T,T>::identity();
+    temp = OP::identity();
     __threadfence();
 
     for (int i = threadId; i < numBlocks; i += numThreads) {
-      temp = OP<T,T,T>{}(temp, device_mem.get(i));
+      temp = OP{}(temp, device_mem.get(i));
     }
 
-    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP<T,T,T>::identity());
+    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP::identity());
 
     // one thread returns value
     if (threadId == 0) {
diff --git a/include/RAJA/policy/hip/params/reduce.hpp b/include/RAJA/policy/hip/params/reduce.hpp
index b91dd7b3f4..68eadeb23c 100644
--- a/include/RAJA/policy/hip/params/reduce.hpp
+++ b/include/RAJA/policy/hip/params/reduce.hpp
@@ -13,40 +13,36 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  init(Reducer<OP, T, I, VType>& red, RAJA::hip::detail::hipInfo& hi)
+  init(Reducer<OP, T, VType>& red, RAJA::hip::detail::hipInfo& hi)
   {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<VT>(1);
+    red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
     red.device_count = RAJA::hip::device_zeroed_mempool_type::getInstance().template malloc<unsigned int>(1);
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  combine(Reducer<OP, T, I, VType>& red)
+  combine(Reducer<OP, T, VType>& red)
   {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP,VT>( red.devicetarget,
+    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP>( red.devicetarget,
                                                                             red.getVal(),
                                                                             red.device_mem,
                                                                             red.device_count);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, I, VType>& red, RAJA::hip::detail::hipInfo& hi)
+  resolve(Reducer<OP, T, VType>& red, RAJA::hip::detail::hipInfo& hi)
   {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-
     // complete reduction
     hi.res.wait();
 
-    red.set(OP<VT,VT,VT>{}(*red.target, *red.devicetarget));
+    red.setTarget(OP{}(*red.target, *red.devicetarget));
 
     // free memory
     RAJA::hip::device_zeroed_mempool_type::getInstance().free(red.device_count);
diff --git a/include/RAJA/policy/hip/reduce.hpp b/include/RAJA/policy/hip/reduce.hpp
index d29d4ec979..c81adf8e24 100644
--- a/include/RAJA/policy/hip/reduce.hpp
+++ b/include/RAJA/policy/hip/reduce.hpp
@@ -194,7 +194,7 @@ RAJA_DEVICE RAJA_INLINE int grid_reduce_last_block(T& val,
 
 namespace expt {
 
-template <typename ThreadIterationGetter, template <typename, typename, typename> class Combiner, typename T>
+template <typename ThreadIterationGetter, typename Combiner, typename T>
 RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 {
   const int numThreads = ThreadIterationGetter::size();
@@ -210,7 +210,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
     // reduce each warp
     for (int i = 1; i < RAJA::policy::hip::device_constants.WARP_SIZE; i *= 2) {
       T rhs = RAJA::hip::impl::shfl_xor_sync(temp, i);
-      temp = Combiner<T,T,T>{}(temp, rhs);
+      temp = Combiner{}(temp, rhs);
     }
 
   } else {
@@ -221,7 +221,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
       T rhs = RAJA::hip::impl::shfl_sync(temp, srcLane);
       // only add from threads that exist (don't double count own value)
       if (srcLane < numThreads) {
-        temp = Combiner<T,T,T>{}(temp, rhs);
+        temp = Combiner{}(temp, rhs);
       }
     }
   }
@@ -257,7 +257,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 
       for (int i = 1; i < RAJA::policy::hip::device_constants.MAX_WARPS; i *= 2) {
         T rhs = RAJA::hip::impl::shfl_xor_sync(temp, i);
-        temp = Combiner<T,T,T>{}(temp, rhs);
+        temp = Combiner{}(temp, rhs);
       }
     }
 
@@ -268,7 +268,7 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 }
 
 
-template <typename GlobalIterationGetter, template <typename, typename, typename> class OP, typename T>
+template <typename GlobalIterationGetter, typename OP, typename T>
 RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
                                           T val,
                                           RAJA::detail::SoAPtr<T,RAJA::hip::device_mempool_type> device_mem,
@@ -284,7 +284,7 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
   const int blockId = BlockIterationGetter::index();
   const int threadId = ThreadIterationGetter::index();
 
-  T temp = block_reduce<ThreadIterationGetter, OP>(val, OP<T,T,T>::identity());
+  T temp = block_reduce<ThreadIterationGetter, OP>(val, OP::identity());
 
   // one thread per block writes to device_mem
   bool lastBlock = false;
@@ -302,14 +302,14 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
 
   // last block accumulates values from device_mem
   if (lastBlock) {
-    temp = OP<T,T,T>::identity();
+    temp = OP::identity();
     __threadfence();
 
     for (int i = threadId; i < numBlocks; i += numThreads) {
-      temp = OP<T,T,T>{}(temp, device_mem.get(i));
+      temp = OP{}(temp, device_mem.get(i));
     }
 
-    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP<T,T,T>::identity());
+    temp = block_reduce<ThreadIterationGetter, OP>(temp, OP::identity());
 
     // one thread returns value
     if (threadId == 0) {
diff --git a/include/RAJA/policy/openmp/params/reduce.hpp b/include/RAJA/policy/openmp/params/reduce.hpp
index c8fcd596d2..944245b990 100644
--- a/include/RAJA/policy/openmp/params/reduce.hpp
+++ b/include/RAJA/policy/openmp/params/reduce.hpp
@@ -10,27 +10,24 @@ namespace detail {
 #if defined(RAJA_ENABLE_OPENMP)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, I, VType>& red) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    red.valop_m.val = OP<VT,VT,VT>::identity();
+  init(Reducer<OP, T, VType>& red) {
+    red.valop_m.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, I, VType>& out, const Reducer<OP, T, I, VType>& in) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    out.valop_m.val = OP<VT,VT,VT>{}(out.valop_m.val, in.valop_m.val);
+  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+    out.valop_m.val = OP{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, I, VType>& red) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    red.set(OP<VT,VT,VT>{}(*red.target, red.valop_m.val));
+  resolve(Reducer<OP, T, VType>& red) {
+    red.setTarget(OP{}(*red.target, red.valop_m.val));
   }
 
 #endif
diff --git a/include/RAJA/policy/openmp_target/params/reduce.hpp b/include/RAJA/policy/openmp_target/params/reduce.hpp
index fdca8109d8..3dcc23bf19 100644
--- a/include/RAJA/policy/openmp_target/params/reduce.hpp
+++ b/include/RAJA/policy/openmp_target/params/reduce.hpp
@@ -10,27 +10,24 @@ namespace detail {
 #if defined(RAJA_ENABLE_TARGET_OPENMP)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, I, VType>& red) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    red.valop_m.val = OP<VT,VT,VT>::identity();
+  init(Reducer<OP, T, VType>& red) {
+    red.valop_m.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, I, VType>& out, const Reducer<OP, T, I, VType>& in) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    out.valop_m.val = OP<VT,VT,VT>{}(out.valop_m.val, in.valop_m.val);
+  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+    out.valop_m.val = OP{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
   resolve(Reducer<OP, T, I, VType>& red) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    red.set(OP<VT,VT,VT>{}(*red.target, red.valop_m.val));
+    red.setTarget(OP{}(*red.target, red.valop_m.val));
   }
 
 #endif
diff --git a/include/RAJA/policy/sequential/params/reduce.hpp b/include/RAJA/policy/sequential/params/reduce.hpp
index 8f70b8eafc..7f9aa26040 100644
--- a/include/RAJA/policy/sequential/params/reduce.hpp
+++ b/include/RAJA/policy/sequential/params/reduce.hpp
@@ -8,27 +8,24 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  init(Reducer<OP, T, I, VType>& red) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    red.valop_m.val = OP<VT,VT,VT>::identity();
+  init(Reducer<OP, T, VType>& red) {
+    red.valop_m.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  combine(Reducer<OP, T, I, VType>& out, const Reducer<OP, T, I, VType>& in) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    out.valop_m.val = OP<VT,VT,VT>{}(out.valop_m.val, in.valop_m.val);
+  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+    out.valop_m.val = OP{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  resolve(Reducer<OP, T, I, VType>& red) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    red.set(OP<VT,VT,VT>{}(*red.target, red.valop_m.val));
+  resolve(Reducer<OP, T, VType>& red) {
+    red.setTarget(OP{}(*red.target, red.valop_m.val));
   }
 
 } //  namespace detail
diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index 4e94a8695c..8bbe5eb6a3 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -10,27 +10,24 @@ namespace detail {
 #if defined(RAJA_ENABLE_SYCL)
 
   // Init
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  init(Reducer<OP, T, I, VType>& red) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    red.valop_m.val = OP<VT,VT,VT>::identity();
+  init(Reducer<OP, T, VType>& red) {
+    red.valop_m.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  combine(Reducer<OP, T, I, VType>& out, const Reducer<OP, T, I, VType>& in) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    out.valop_m.val = OP<VT,VT,VT>{}(out.valop_m.val, in.valop_m.val);
+  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+    out.valop_m.val = OP{}(out.valop_m.val, in.valop_m.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, template <typename, typename, typename> class OP, typename T, typename I, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, I, VType>& red) {
-    using VT = typename Reducer<OP, T, I, VType>::value_type;
-    red.set(OP<VT,VT,VT>{}(*red.target, red.valop_m.val));
+  resolve(Reducer<OP, T, VType>& red) {
+    red.setTarget(OP{}(*red.target, red.valop_m.val));
   }
 
 #endif

From 28a96dc46135c25e3ad54b503ffd2d840a704b9b Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 3 Oct 2024 14:57:22 -0700
Subject: [PATCH 75/82] Documentation updates.

---
 docs/sphinx/user_guide/feature/reduction.rst | 53 ++++++++++++--------
 1 file changed, 32 insertions(+), 21 deletions(-)

diff --git a/docs/sphinx/user_guide/feature/reduction.rst b/docs/sphinx/user_guide/feature/reduction.rst
index 9d9f64e5fe..f0a565e58c 100644
--- a/docs/sphinx/user_guide/feature/reduction.rst
+++ b/docs/sphinx/user_guide/feature/reduction.rst
@@ -240,15 +240,19 @@ RAJA::expt::Reduce
           compatible with the ``EXEC_POL``. ``Seg`` is the iteration space
           object for ``RAJA::forall``.
 
-.. important:: The local reduction arguments to the lambda expression must be
-               ``RAJA::expt::ValOp`` references. Each ``ValOp`` references
-               corresponds to a ``RAJA::expt::Reduce`` call within the forall
-               arguments. The ``ValOp`` reduction data type and RAJA operator need
-               to match the data type referenced and operator template argument
-               in the ``RAJA::expt::Reduce`` call. Finally, the ordering of the
-               ``ValOp`` references must correspond to the ordering of the
-               ``RAJA::expt::Reduce`` calls to ensure that the correct result is
-               obtained.
+.. important:: * ``RAJA::expt::Reduce`` arguments must be passed to the forall.
+                 These arguments are templated on the reduction operator, and take
+                 a pointer to the target reduction variable that was declared outside
+                 of the forall.
+               * The local reduction arguments to the lambda expression must be
+                 ``RAJA::expt::ValOp`` references. Each ``ValOp`` reference
+                 corresponds to a ``RAJA::expt::Reduce`` argument within the forall.
+               * The ordering of the ``ValOp`` references must correspond to the
+                 ordering of the ``RAJA::expt::Reduce`` arguments to ensure that the
+                 correct result is obtained.
+               * Each ``ValOp`` reduction data type and RAJA operator need to match
+                 the data type referenced, and operator template argument in the
+                 corresponding ``RAJA::expt::Reduce`` argument.
 
 RAJA::expt::ValLoc
 ..................
@@ -258,14 +262,18 @@ reductions, which provide the ability to get a kernel/loop index at which the
 final reduction value was found. With this new interface, *loc* reductions
 are performed using ``ValLoc<T,I>`` types, where ``T`` is the underlying data type,
 and ``I`` is the index type. Users must use the ``getVal()`` and ``getLoc()``
-methods to access the reduction results.
+methods to access the reduction results after the kernel completes.
+
+In the lambda expression, a ``ValLoc<T,I>`` must be wrapped in a
+``ValOp`` type, and passed to the lambda in the same order as the corresponding 
+``RAJA::expt::Reduce`` arguments, e.g. ``ValOp<ValLoc<T,I>, Op>``. In the example
+below, ``VALOPLOC_DOUBLE_MIN`` represents a wrapped ``ValLoc`` usable within the
+lambda.
 
-In the kernel body lambda expression, a ``ValLoc<T,I>`` must be wrapped in a
-``ValOp``, and passed to the lambda in the same order as the corresponding 
-``RAJA::expt::Reduce`` arguments, e.g. ``ValOp<ValLoc<T,I>, Op>``.
 For convenience, an alias of ``RAJA::expt::ValLocOp<T,I,Op>`` is provided.
 Within the lambda, this ``ValLocOp`` object provides ``minloc``, and ``maxloc``
-functions::
+functions. In the example below, ``VALOPLOC_DOUBLE_MAX`` represents a wrapped
+``ValLoc`` using the ``ValLocOp`` alias::
 
   double* a = ...;
 
@@ -293,11 +301,13 @@ functions::
   std::cout << rmax_loc.getLoc() ...
 
 Alternatively, *loc* reductions can be performed on separate reduction data, and
-location variables without a ``ValLoc`` object. To use this capability, a
-``RAJA::expt::ReduceLoc`` call must be passed to the ``RAJA::forall``, templated on
-the reduction operation, and passing in references to the data and location as
-``ReduceLoc`` function arguments. The data and location can be accessed outside of
-the forall directly without ``getVal()`` or ``getLoc()`` functions.
+location variables without a ``ValLoc`` object, seen in the next example below.
+To use this capability, a ``RAJA::expt::ReduceLoc`` argument must be passed to the
+``RAJA::forall``, templated on the reduction operation, and passing in references to
+the data and location. This is illustrated in the example below, with references to
+``rm`` and ``loc`` being passed into the ``ReduceLoc`` argument in the forall. The
+data and location can be accessed outside of the forall directly without
+``getVal()`` or ``getLoc()`` functions.
 :: 
 
   double* a = ...;
@@ -310,12 +320,13 @@ the forall directly without ``getVal()`` or ``getLoc()`` functions.
   RAJA::Index_type loc;
 
   RAJA::forall<EXEC_POL> ( Res, Seg,
-  RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&rm, &loc),
+  RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&rm, &loc), // --> 1 double & 1 index added
   [=] (int i, VALOPLOC_DOUBLE_MIN& _rm_loc) {
     _rm_loc.minloc(a[i], i);
   }
   );
 
+  // No getVal() or getLoc() required. Access results in their original form.
   std::cout << rm ...
   std::cout << loc ...
 
@@ -324,7 +335,7 @@ Lambda Arguments
 ................
 
 This interface takes advantage of C++ parameter packs to allow users to pass
-any number of ``RAJA::expt::Reduce`` objects to the ``RAJA::forall`` method::
+any number of ``RAJA::expt::Reduce`` arguments to the ``RAJA::forall`` method::
 
   double* a = ...;
 

From 21c4414e9364f8cf6f69379e93b4e43cc320c5e1 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Thu, 3 Oct 2024 15:06:18 -0700
Subject: [PATCH 76/82] Update error message for ordering of ValOp and Reduce
 args.

---
 docs/sphinx/user_guide/feature/reduction.rst | 2 +-
 include/RAJA/pattern/params/forall.hpp       | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/sphinx/user_guide/feature/reduction.rst b/docs/sphinx/user_guide/feature/reduction.rst
index f0a565e58c..96c1a408a0 100644
--- a/docs/sphinx/user_guide/feature/reduction.rst
+++ b/docs/sphinx/user_guide/feature/reduction.rst
@@ -374,7 +374,7 @@ data types and operators, and order of the ``ValOp`` parameters must match
 the corresponding ``RAJA::expt::Reduce`` types to get correct results and to
 compile successfully. Otherwise, a static assertion will be triggered::
 
-  LAMBDA Not invocable w/ EXPECTED_ARGS.
+  LAMBDA Not invocable w/ EXPECTED_ARGS. Ordering and types must match between RAJA::expt::Reduce() and ValOp arguments.
 
 .. note:: This static assert is only enabled when passing an undecorated C++
           lambda. Meaning, this check will not happen when passing
diff --git a/include/RAJA/pattern/params/forall.hpp b/include/RAJA/pattern/params/forall.hpp
index fb854c8706..5a656206f5 100644
--- a/include/RAJA/pattern/params/forall.hpp
+++ b/include/RAJA/pattern/params/forall.hpp
@@ -276,7 +276,7 @@ namespace expt
     template<typename LAMBDA, typename... EXPECTED_ARGS>
     constexpr concepts::enable_if<has_empty_op<LAMBDA>> check_invocable(LAMBDA&&, const camp::list<EXPECTED_ARGS...>&) {
 #if !defined(RAJA_ENABLE_HIP)
-      static_assert(is_invocable<LAMBDA, typename get_lambda_index_type<LAMBDA>::type, EXPECTED_ARGS...>::value, "LAMBDA Not invocable w/ EXPECTED_ARGS."); 
+      static_assert(is_invocable<LAMBDA, typename get_lambda_index_type<LAMBDA>::type, EXPECTED_ARGS...>::value, "LAMBDA Not invocable w/ EXPECTED_ARGS. Ordering and types must match between RAJA::expt::Reduce() and ValOp arguments."); 
 #endif
     }
 

From c68db6c7144bcb110940e4b9a6ba3fa2f6213804 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 4 Oct 2024 14:40:05 -0700
Subject: [PATCH 77/82] More template simplifications.

---
 include/RAJA/pattern/params/reducer.hpp | 26 ++++++++++---------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index d5f1362040..59f0f9928f 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -58,11 +58,10 @@ namespace detail
 
   // Basic data type Reducer
   // T must be a basic data type
-  // IndexType not used here
   // VType must be ValOp<T, Op>
   template <typename Op, typename T, typename VType>
   struct Reducer : public ForallParamBase {
-    //using op = Op<T,T,T>;
+    using op = Op;
     using value_type = T; // This is a basic data type
 
     Reducer() = default;
@@ -104,16 +103,13 @@ namespace detail
   };
 
   // Partial specialization of Reducer for ValLoc
-  // T must be a ValLoc
-  // TTOp is the template template version of Op, required by ValOp
-  // VType must be ValOp<ValLoc<>,Op>
-  template <typename Op, typename T, template <typename, typename, typename> class TTOp>
-  struct Reducer<Op, T, ValOp<ValLoc<typename T::value_type, typename T::index_type>, TTOp>> : public ForallParamBase {
-    using target_value_type = typename T::value_type; // This should be a basic data type extracted from the T=ValLoc passed in
-    using target_index_type = typename T::index_type;
-    using value_type = T; // Note that this struct operates on ValLoc
-    using op = TTOp<value_type,value_type,value_type>;
-    using VType = ValOp<ValLoc<target_value_type,target_index_type>, TTOp>;
+  template <typename T, typename I, template <typename, typename, typename> class Op>
+  struct Reducer<Op<ValLoc<T,I>, ValLoc<T,I>, ValLoc<T,I>>, ValLoc<T,I>, ValOp<ValLoc<T,I>, Op>> : public ForallParamBase {
+    using target_value_type = T;
+    using target_index_type = I;
+    using value_type = ValLoc<T,I>;
+    using op = Op<value_type,value_type,value_type>;
+    using VType = ValOp<ValLoc<target_value_type,target_index_type>, Op>;
 
     Reducer() = default;
 
@@ -164,8 +160,7 @@ namespace detail
 } // namespace detail
 
 // Standard use case.
-template <template <typename, typename, typename> class Op, typename T, typename IndexType = RAJA::Index_type,
-          std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value> * = nullptr>
+template <template <typename, typename, typename> class Op, typename T>
 auto constexpr Reduce(T *target)
 {
   return detail::Reducer<Op<T,T,T>, T, ValOp<T, Op>>(target);
@@ -180,8 +175,7 @@ auto constexpr Reduce(ValLoc<T, IndexType> *target)
 }
 
 // Pass through use case where reduction value and location are separate, non-ValLoc types supplied by the user.
-template <template <typename, typename, typename> class Op, typename T, typename IndexType,
-          std::enable_if_t<std::is_integral<T>::value || std::is_floating_point<T>::value> * = nullptr>
+template <template <typename, typename, typename> class Op, typename T, typename IndexType>
 auto constexpr ReduceLoc(T *target, IndexType *index)
 {
   using VL = ValLoc<T,IndexType>;

From 8a61199b81ed6021955a63e17358f69142d10e7f Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 4 Oct 2024 14:44:54 -0700
Subject: [PATCH 78/82] Change member variable naming convention.

---
 include/RAJA/pattern/params/reducer.hpp        | 18 +++++++++---------
 include/RAJA/policy/openmp/params/reduce.hpp   |  6 +++---
 .../policy/openmp_target/params/reduce.hpp     |  6 +++---
 .../RAJA/policy/sequential/params/reduce.hpp   |  6 +++---
 include/RAJA/policy/sycl/params/reduce.hpp     |  6 +++---
 5 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 59f0f9928f..0e635c21d9 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -67,7 +67,7 @@ namespace detail
     Reducer() = default;
 
     // Basic data type constructor
-    RAJA_HOST_DEVICE Reducer(value_type *target_in) : valop_m(VType{}), target(target_in){}
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VType{}), target(target_in){}
 
     Reducer(Reducer const &) = default;
     Reducer(Reducer &&) = default;
@@ -75,7 +75,7 @@ namespace detail
     Reducer& operator=(Reducer &&) = default;
 
     // Internal ValOp object that is used within RAJA::forall/launch
-    VType valop_m = VType{};
+    VType m_valop = VType{};
 
     // Points to the user specified result variable
     value_type *target = nullptr;
@@ -85,7 +85,7 @@ namespace detail
 
     RAJA_HOST_DEVICE
     value_type &
-    getVal() { return valop_m.val; }
+    getVal() { return m_valop.val; }
 
 #if defined(RAJA_CUDA_ACTIVE) || defined(RAJA_HIP_ACTIVE) || defined(RAJA_SYCL_ACTIVE)
     // Device related attributes.
@@ -96,7 +96,7 @@ namespace detail
 
     // These are types and parameters extracted from this struct, and given to the forall.
     using ARG_TUP_T = camp::tuple<VType*>;
-    RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&valop_m); }
+    RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&m_valop); }
 
     using ARG_LIST_T = typename ARG_TUP_T::TList;
     static constexpr size_t num_lambda_args = camp::tuple_size<ARG_TUP_T>::value ;
@@ -115,18 +115,18 @@ namespace detail
 
     // ValLoc constructor
     // Note that the passthru variables point to the val and loc within the user defined target ValLoc
-    RAJA_HOST_DEVICE Reducer(value_type *target_in) : valop_m(VType{}), target(target_in), passthruval(&target_in->val), passthruindex(&target_in->loc) {}
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VType{}), target(target_in), passthruval(&target_in->val), passthruindex(&target_in->loc) {}
 
     // Pass through constructor for ReduceLoc<>(data, index) case
     // The passthru variables point to vars defined by the user
-    RAJA_HOST_DEVICE Reducer(target_value_type *data_in, target_index_type *index_in) : valop_m(VType(*data_in, *index_in)), target(&valop_m.val), passthruval(data_in), passthruindex(index_in) {}
+    RAJA_HOST_DEVICE Reducer(target_value_type *data_in, target_index_type *index_in) : m_valop(VType(*data_in, *index_in)), target(&m_valop.val), passthruval(data_in), passthruindex(index_in) {}
 
     Reducer(Reducer const &) = default;
     Reducer(Reducer &&) = default;
     Reducer& operator=(Reducer const &) = default;
     Reducer& operator=(Reducer &&) = default;
 
-    VType valop_m = VType{};
+    VType m_valop = VType{};
 
     value_type *target = nullptr;
 
@@ -140,7 +140,7 @@ namespace detail
 
     RAJA_HOST_DEVICE
     value_type &
-    getVal() { return valop_m.val; }
+    getVal() { return m_valop.val; }
 
 #if defined(RAJA_CUDA_ACTIVE) || defined(RAJA_HIP_ACTIVE) || defined(RAJA_SYCL_ACTIVE)
     // Device related attributes.
@@ -151,7 +151,7 @@ namespace detail
 
     // These are types and parameters extracted from this struct, and given to the forall.
     using ARG_TUP_T = camp::tuple<VType*>;
-    RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&valop_m); }
+    RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&m_valop); }
 
     using ARG_LIST_T = typename ARG_TUP_T::TList;
     static constexpr size_t num_lambda_args = camp::tuple_size<ARG_TUP_T>::value ;
diff --git a/include/RAJA/policy/openmp/params/reduce.hpp b/include/RAJA/policy/openmp/params/reduce.hpp
index 944245b990..54a616f5ef 100644
--- a/include/RAJA/policy/openmp/params/reduce.hpp
+++ b/include/RAJA/policy/openmp/params/reduce.hpp
@@ -13,21 +13,21 @@ namespace detail {
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
   init(Reducer<OP, T, VType>& red) {
-    red.valop_m.val = OP::identity();
+    red.m_valop.val = OP::identity();
   }
 
   // Combine
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
   combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-    out.valop_m.val = OP{}(out.valop_m.val, in.valop_m.val);
+    out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
   resolve(Reducer<OP, T, VType>& red) {
-    red.setTarget(OP{}(*red.target, red.valop_m.val));
+    red.setTarget(OP{}(*red.target, red.m_valop.val));
   }
 
 #endif
diff --git a/include/RAJA/policy/openmp_target/params/reduce.hpp b/include/RAJA/policy/openmp_target/params/reduce.hpp
index 3dcc23bf19..37a270a285 100644
--- a/include/RAJA/policy/openmp_target/params/reduce.hpp
+++ b/include/RAJA/policy/openmp_target/params/reduce.hpp
@@ -13,21 +13,21 @@ namespace detail {
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
   init(Reducer<OP, T, VType>& red) {
-    red.valop_m.val = OP::identity();
+    red.m_valop.val = OP::identity();
   }
 
   // Combine
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
   combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-    out.valop_m.val = OP{}(out.valop_m.val, in.valop_m.val);
+    out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
   resolve(Reducer<OP, T, I, VType>& red) {
-    red.setTarget(OP{}(*red.target, red.valop_m.val));
+    red.setTarget(OP{}(*red.target, red.m_valop.val));
   }
 
 #endif
diff --git a/include/RAJA/policy/sequential/params/reduce.hpp b/include/RAJA/policy/sequential/params/reduce.hpp
index 7f9aa26040..bbd491c83d 100644
--- a/include/RAJA/policy/sequential/params/reduce.hpp
+++ b/include/RAJA/policy/sequential/params/reduce.hpp
@@ -11,21 +11,21 @@ namespace detail {
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
   init(Reducer<OP, T, VType>& red) {
-    red.valop_m.val = OP::identity();
+    red.m_valop.val = OP::identity();
   }
 
   // Combine
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
   combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-    out.valop_m.val = OP{}(out.valop_m.val, in.valop_m.val);
+    out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
   resolve(Reducer<OP, T, VType>& red) {
-    red.setTarget(OP{}(*red.target, red.valop_m.val));
+    red.setTarget(OP{}(*red.target, red.m_valop.val));
   }
 
 } //  namespace detail
diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index 8bbe5eb6a3..55c77b5f5a 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -13,21 +13,21 @@ namespace detail {
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   init(Reducer<OP, T, VType>& red) {
-    red.valop_m.val = OP::identity();
+    red.m_valop.val = OP::identity();
   }
 
   // Combine
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
-    out.valop_m.val = OP{}(out.valop_m.val, in.valop_m.val);
+    out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   resolve(Reducer<OP, T, VType>& red) {
-    red.setTarget(OP{}(*red.target, red.valop_m.val));
+    red.setTarget(OP{}(*red.target, red.m_valop.val));
   }
 
 #endif

From cd64e230936c2c021ab113c6a1f7f265d2cb24c6 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Fri, 4 Oct 2024 17:01:59 -0700
Subject: [PATCH 79/82] Simplify ValLoc Reducer case. Perform final combine in
 Reducer.

---
 include/RAJA/pattern/params/reducer.hpp       | 43 ++++++++++++-------
 include/RAJA/policy/cuda/params/reduce.hpp    |  2 +-
 include/RAJA/policy/hip/params/reduce.hpp     |  2 +-
 include/RAJA/policy/openmp/params/reduce.hpp  |  2 +-
 .../policy/openmp_target/params/reduce.hpp    |  2 +-
 .../RAJA/policy/sequential/params/reduce.hpp  |  2 +-
 include/RAJA/policy/sycl/params/reduce.hpp    |  2 +-
 7 files changed, 33 insertions(+), 22 deletions(-)

diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 0e635c21d9..2b9df27a1a 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -80,8 +80,12 @@ namespace detail
     // Points to the user specified result variable
     value_type *target = nullptr;
 
-    // Used in the resolve() call to set target in each backend
-    RAJA_HOST_DEVICE void setTarget(value_type in) { *target = in; }
+    // combineTarget() performs the final op on the target data and location in resolve()
+    RAJA_HOST_DEVICE void combineTarget(value_type in)
+    {
+      value_type temp = op{}(*target, in);
+      *target = temp;
+    }
 
     RAJA_HOST_DEVICE
     value_type &
@@ -103,6 +107,8 @@ namespace detail
   };
 
   // Partial specialization of Reducer for ValLoc
+  // T is a deduced basic data type
+  // I is a deduced index type
   template <typename T, typename I, template <typename, typename, typename> class Op>
   struct Reducer<Op<ValLoc<T,I>, ValLoc<T,I>, ValLoc<T,I>>, ValLoc<T,I>, ValOp<ValLoc<T,I>, Op>> : public ForallParamBase {
     using target_value_type = T;
@@ -114,29 +120,34 @@ namespace detail
     Reducer() = default;
 
     // ValLoc constructor
-    // Note that the passthru variables point to the val and loc within the user defined target ValLoc
-    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VType{}), target(target_in), passthruval(&target_in->val), passthruindex(&target_in->loc) {}
+    // Note that the target_ variables point to the val and loc within the user defined target ValLoc
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VType(target_in->val, target_in->loc)), target_value(&target_in->val), target_index(&target_in->loc) {}
 
-    // Pass through constructor for ReduceLoc<>(data, index) case
-    // The passthru variables point to vars defined by the user
-    RAJA_HOST_DEVICE Reducer(target_value_type *data_in, target_index_type *index_in) : m_valop(VType(*data_in, *index_in)), target(&m_valop.val), passthruval(data_in), passthruindex(index_in) {}
+    // Dual input constructor for ReduceLoc<>(data, index) case
+    // The target_ variables point to vars defined by the user
+    RAJA_HOST_DEVICE Reducer(target_value_type *data_in, target_index_type *index_in) : m_valop(VType(*data_in, *index_in)), target_value(data_in), target_index(index_in) {}
 
     Reducer(Reducer const &) = default;
     Reducer(Reducer &&) = default;
     Reducer& operator=(Reducer const &) = default;
     Reducer& operator=(Reducer &&) = default;
 
+    // The ValLoc within m_valop is initialized with data and location values from either a ValLoc, or dual data and location values, passed into the constructor
     VType m_valop = VType{};
 
-    value_type *target = nullptr;
-
-    target_value_type *passthruval = nullptr;
-    target_index_type *passthruindex = nullptr;
+    // Points to either dual value and index defined by the user, or value and index within a ValLoc defined by the user
+    target_value_type *target_value = nullptr;
+    target_index_type *target_index = nullptr;
 
-    // This single-argument setTarget() matches the basic data type Reducer::setTarget()'s
-    // function signature to make the init/combine/resolve backend calls easier
-    // to maintain, but operates on the passthru variables instead
-    RAJA_HOST_DEVICE void setTarget(value_type in) { *passthruval = in.val; *passthruindex = in.loc; }
+    // combineTarget() performs the final op on the target data and location in resolve()
+    RAJA_HOST_DEVICE void combineTarget(value_type in)
+    {
+      // Create a different temp ValLoc solely for combining
+      value_type temp(*target_value, *target_index);
+      temp = op{}(temp, in);
+      *target_value = temp.val;
+      *target_index = temp.loc;
+    }
 
     RAJA_HOST_DEVICE
     value_type &
@@ -174,7 +185,7 @@ auto constexpr Reduce(ValLoc<T, IndexType> *target)
   return detail::Reducer<Op<VL,VL,VL>, VL, ValOp<ValLoc<T, IndexType>, Op>>(target);
 }
 
-// Pass through use case where reduction value and location are separate, non-ValLoc types supplied by the user.
+// Dual input use case where reduction value and location are separate, non-ValLoc types supplied by the user.
 template <template <typename, typename, typename> class Op, typename T, typename IndexType>
 auto constexpr ReduceLoc(T *target, IndexType *index)
 {
diff --git a/include/RAJA/policy/cuda/params/reduce.hpp b/include/RAJA/policy/cuda/params/reduce.hpp
index 7cf7ea984d..059a6a17f9 100644
--- a/include/RAJA/policy/cuda/params/reduce.hpp
+++ b/include/RAJA/policy/cuda/params/reduce.hpp
@@ -44,7 +44,7 @@ namespace detail {
     // complete reduction
     ci.res.wait();
 
-    red.setTarget(OP{}(*red.target, *red.devicetarget));
+    red.combineTarget(*red.devicetarget);
 
     // free memory
     RAJA::cuda::device_zeroed_mempool_type::getInstance().free(red.device_count);
diff --git a/include/RAJA/policy/hip/params/reduce.hpp b/include/RAJA/policy/hip/params/reduce.hpp
index 68eadeb23c..7a0f9db23c 100644
--- a/include/RAJA/policy/hip/params/reduce.hpp
+++ b/include/RAJA/policy/hip/params/reduce.hpp
@@ -42,7 +42,7 @@ namespace detail {
     // complete reduction
     hi.res.wait();
 
-    red.setTarget(OP{}(*red.target, *red.devicetarget));
+    red.combineTarget(*red.devicetarget);
 
     // free memory
     RAJA::hip::device_zeroed_mempool_type::getInstance().free(red.device_count);
diff --git a/include/RAJA/policy/openmp/params/reduce.hpp b/include/RAJA/policy/openmp/params/reduce.hpp
index 54a616f5ef..a5c40feaf0 100644
--- a/include/RAJA/policy/openmp/params/reduce.hpp
+++ b/include/RAJA/policy/openmp/params/reduce.hpp
@@ -27,7 +27,7 @@ namespace detail {
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
   resolve(Reducer<OP, T, VType>& red) {
-    red.setTarget(OP{}(*red.target, red.m_valop.val));
+    red.combineTarget(red.m_valop.val);
   }
 
 #endif
diff --git a/include/RAJA/policy/openmp_target/params/reduce.hpp b/include/RAJA/policy/openmp_target/params/reduce.hpp
index 37a270a285..8ee24bb6f1 100644
--- a/include/RAJA/policy/openmp_target/params/reduce.hpp
+++ b/include/RAJA/policy/openmp_target/params/reduce.hpp
@@ -27,7 +27,7 @@ namespace detail {
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
   resolve(Reducer<OP, T, I, VType>& red) {
-    red.setTarget(OP{}(*red.target, red.m_valop.val));
+    red.combineTarget(red.m_valop.val);
   }
 
 #endif
diff --git a/include/RAJA/policy/sequential/params/reduce.hpp b/include/RAJA/policy/sequential/params/reduce.hpp
index bbd491c83d..08481bb054 100644
--- a/include/RAJA/policy/sequential/params/reduce.hpp
+++ b/include/RAJA/policy/sequential/params/reduce.hpp
@@ -25,7 +25,7 @@ namespace detail {
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
   resolve(Reducer<OP, T, VType>& red) {
-    red.setTarget(OP{}(*red.target, red.m_valop.val));
+    red.combineTarget(red.m_valop.val);
   }
 
 } //  namespace detail
diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index 55c77b5f5a..b89e7e9002 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -27,7 +27,7 @@ namespace detail {
   template<typename EXEC_POL, typename OP, typename T, typename VType>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
   resolve(Reducer<OP, T, VType>& red) {
-    red.setTarget(OP{}(*red.target, red.m_valop.val));
+    red.combineTarget(red.m_valop.val);
   }
 
 #endif

From e48637c2332fc859b3c4e0399ffdbfe319d346ba Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Mon, 7 Oct 2024 10:52:45 -0700
Subject: [PATCH 80/82] Reword.

---
 docs/sphinx/user_guide/feature/reduction.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/sphinx/user_guide/feature/reduction.rst b/docs/sphinx/user_guide/feature/reduction.rst
index 96c1a408a0..6b24ad98b0 100644
--- a/docs/sphinx/user_guide/feature/reduction.rst
+++ b/docs/sphinx/user_guide/feature/reduction.rst
@@ -222,8 +222,8 @@ RAJA::expt::Reduce
   on the underlying data type (``double`` for ``_rs`` and ``_rm``), and the operator
   being used. It is important to note that the parameters follow the kernel iteration
   variable, ``i`` in this case, and appear in the same order as the corresponding
-  ``RAJA::expt::Reduce`` arguments to ``RAJA::forall``. The parameter types must be
-  references to the types used in the ``RAJA::expt::Reduce`` arguments.
+  ``RAJA::expt::Reduce`` arguments to ``RAJA::forall``. The ``ValOp`` parameters must
+  be references to the objects instantiated by the ``RAJA::expt::Reduce`` arguments.
 * The local variables referred to by ``_rs`` and ``_rm`` are initialized with
   the *identity* of the reduction operation to be performed.
 * The local variables are updated in the user supplied lambda.

From bc3304071d97ba080ad481286dd7bae9e930399e Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Mon, 7 Oct 2024 10:53:08 -0700
Subject: [PATCH 81/82] Change VType to VOp.

---
 include/RAJA/pattern/params/reducer.hpp       | 20 +++++++++----------
 include/RAJA/policy/cuda/params/reduce.hpp    | 12 +++++------
 include/RAJA/policy/hip/params/reduce.hpp     | 12 +++++------
 include/RAJA/policy/openmp/params/reduce.hpp  | 12 +++++------
 .../policy/openmp_target/params/reduce.hpp    | 12 +++++------
 .../RAJA/policy/sequential/params/reduce.hpp  | 12 +++++------
 include/RAJA/policy/sycl/params/reduce.hpp    | 12 +++++------
 7 files changed, 46 insertions(+), 46 deletions(-)

diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 2b9df27a1a..597705c8da 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -58,8 +58,8 @@ namespace detail
 
   // Basic data type Reducer
   // T must be a basic data type
-  // VType must be ValOp<T, Op>
-  template <typename Op, typename T, typename VType>
+  // VOp must be ValOp<T, Op>
+  template <typename Op, typename T, typename VOp>
   struct Reducer : public ForallParamBase {
     using op = Op;
     using value_type = T; // This is a basic data type
@@ -67,7 +67,7 @@ namespace detail
     Reducer() = default;
 
     // Basic data type constructor
-    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VType{}), target(target_in){}
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VOp{}), target(target_in){}
 
     Reducer(Reducer const &) = default;
     Reducer(Reducer &&) = default;
@@ -75,7 +75,7 @@ namespace detail
     Reducer& operator=(Reducer &&) = default;
 
     // Internal ValOp object that is used within RAJA::forall/launch
-    VType m_valop = VType{};
+    VOp m_valop = VOp{};
 
     // Points to the user specified result variable
     value_type *target = nullptr;
@@ -99,7 +99,7 @@ namespace detail
 #endif
 
     // These are types and parameters extracted from this struct, and given to the forall.
-    using ARG_TUP_T = camp::tuple<VType*>;
+    using ARG_TUP_T = camp::tuple<VOp*>;
     RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&m_valop); }
 
     using ARG_LIST_T = typename ARG_TUP_T::TList;
@@ -115,17 +115,17 @@ namespace detail
     using target_index_type = I;
     using value_type = ValLoc<T,I>;
     using op = Op<value_type,value_type,value_type>;
-    using VType = ValOp<ValLoc<target_value_type,target_index_type>, Op>;
+    using VOp = ValOp<ValLoc<target_value_type,target_index_type>, Op>;
 
     Reducer() = default;
 
     // ValLoc constructor
     // Note that the target_ variables point to the val and loc within the user defined target ValLoc
-    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VType(target_in->val, target_in->loc)), target_value(&target_in->val), target_index(&target_in->loc) {}
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VOp(target_in->val, target_in->loc)), target_value(&target_in->val), target_index(&target_in->loc) {}
 
     // Dual input constructor for ReduceLoc<>(data, index) case
     // The target_ variables point to vars defined by the user
-    RAJA_HOST_DEVICE Reducer(target_value_type *data_in, target_index_type *index_in) : m_valop(VType(*data_in, *index_in)), target_value(data_in), target_index(index_in) {}
+    RAJA_HOST_DEVICE Reducer(target_value_type *data_in, target_index_type *index_in) : m_valop(VOp(*data_in, *index_in)), target_value(data_in), target_index(index_in) {}
 
     Reducer(Reducer const &) = default;
     Reducer(Reducer &&) = default;
@@ -133,7 +133,7 @@ namespace detail
     Reducer& operator=(Reducer &&) = default;
 
     // The ValLoc within m_valop is initialized with data and location values from either a ValLoc, or dual data and location values, passed into the constructor
-    VType m_valop = VType{};
+    VOp m_valop = VOp{};
 
     // Points to either dual value and index defined by the user, or value and index within a ValLoc defined by the user
     target_value_type *target_value = nullptr;
@@ -161,7 +161,7 @@ namespace detail
 #endif
 
     // These are types and parameters extracted from this struct, and given to the forall.
-    using ARG_TUP_T = camp::tuple<VType*>;
+    using ARG_TUP_T = camp::tuple<VOp*>;
     RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&m_valop); }
 
     using ARG_LIST_T = typename ARG_TUP_T::TList;
diff --git a/include/RAJA/policy/cuda/params/reduce.hpp b/include/RAJA/policy/cuda/params/reduce.hpp
index 059a6a17f9..6ab3372aaa 100644
--- a/include/RAJA/policy/cuda/params/reduce.hpp
+++ b/include/RAJA/policy/cuda/params/reduce.hpp
@@ -15,9 +15,9 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
+  init(Reducer<OP, T, VOp>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
     red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
@@ -25,10 +25,10 @@ namespace detail {
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& red)
+  combine(Reducer<OP, T, VOp>& red)
   {
     RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP>(red.devicetarget,
                                                                             red.getVal(),
@@ -37,9 +37,9 @@ namespace detail {
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red, RAJA::cuda::detail::cudaInfo& ci)
+  resolve(Reducer<OP, T, VOp>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
     // complete reduction
     ci.res.wait();
diff --git a/include/RAJA/policy/hip/params/reduce.hpp b/include/RAJA/policy/hip/params/reduce.hpp
index 7a0f9db23c..a3da07ee2c 100644
--- a/include/RAJA/policy/hip/params/reduce.hpp
+++ b/include/RAJA/policy/hip/params/reduce.hpp
@@ -13,9 +13,9 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red, RAJA::hip::detail::hipInfo& hi)
+  init(Reducer<OP, T, VOp>& red, RAJA::hip::detail::hipInfo& hi)
   {
     red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
@@ -23,10 +23,10 @@ namespace detail {
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& red)
+  combine(Reducer<OP, T, VOp>& red)
   {
     RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP>( red.devicetarget,
                                                                             red.getVal(),
@@ -35,9 +35,9 @@ namespace detail {
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red, RAJA::hip::detail::hipInfo& hi)
+  resolve(Reducer<OP, T, VOp>& red, RAJA::hip::detail::hipInfo& hi)
   {
     // complete reduction
     hi.res.wait();
diff --git a/include/RAJA/policy/openmp/params/reduce.hpp b/include/RAJA/policy/openmp/params/reduce.hpp
index a5c40feaf0..f71efc255a 100644
--- a/include/RAJA/policy/openmp/params/reduce.hpp
+++ b/include/RAJA/policy/openmp/params/reduce.hpp
@@ -10,23 +10,23 @@ namespace detail {
 #if defined(RAJA_ENABLE_OPENMP)
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red) {
+  init(Reducer<OP, T, VOp>& red) {
     red.m_valop.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+  combine(Reducer<OP, T, VOp>& out, const Reducer<OP, T, VOp>& in) {
     out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red) {
+  resolve(Reducer<OP, T, VOp>& red) {
     red.combineTarget(red.m_valop.val);
   }
 
diff --git a/include/RAJA/policy/openmp_target/params/reduce.hpp b/include/RAJA/policy/openmp_target/params/reduce.hpp
index 8ee24bb6f1..6127eef226 100644
--- a/include/RAJA/policy/openmp_target/params/reduce.hpp
+++ b/include/RAJA/policy/openmp_target/params/reduce.hpp
@@ -10,23 +10,23 @@ namespace detail {
 #if defined(RAJA_ENABLE_TARGET_OPENMP)
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red) {
+  init(Reducer<OP, T, VOp>& red) {
     red.m_valop.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+  combine(Reducer<OP, T, VOp>& out, const Reducer<OP, T, VOp>& in) {
     out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, I, VType>& red) {
+  resolve(Reducer<OP, T, I, VOp>& red) {
     red.combineTarget(red.m_valop.val);
   }
 
diff --git a/include/RAJA/policy/sequential/params/reduce.hpp b/include/RAJA/policy/sequential/params/reduce.hpp
index 08481bb054..b77028ca5f 100644
--- a/include/RAJA/policy/sequential/params/reduce.hpp
+++ b/include/RAJA/policy/sequential/params/reduce.hpp
@@ -8,23 +8,23 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  init(Reducer<OP, T, VType>& red) {
+  init(Reducer<OP, T, VOp>& red) {
     red.m_valop.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+  combine(Reducer<OP, T, VOp>& out, const Reducer<OP, T, VOp>& in) {
     out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  resolve(Reducer<OP, T, VType>& red) {
+  resolve(Reducer<OP, T, VOp>& red) {
     red.combineTarget(red.m_valop.val);
   }
 
diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index b89e7e9002..e2fb7e1a5a 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -10,23 +10,23 @@ namespace detail {
 #if defined(RAJA_ENABLE_SYCL)
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  init(Reducer<OP, T, VType>& red) {
+  init(Reducer<OP, T, VOp>& red) {
     red.m_valop.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  combine(Reducer<OP, T, VType>& out, const Reducer<OP, T, VType>& in) {
+  combine(Reducer<OP, T, VOp>& out, const Reducer<OP, T, VOp>& in) {
     out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T, typename VType>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  resolve(Reducer<OP, T, VType>& red) {
+  resolve(Reducer<OP, T, VOp>& red) {
     red.combineTarget(red.m_valop.val);
   }
 

From b5d58455c2b420d89673988e17a9433206baa611 Mon Sep 17 00:00:00 2001
From: Robert Chen <chen59@llnl.gov>
Date: Mon, 7 Oct 2024 17:28:08 -0700
Subject: [PATCH 82/82] Initialize ValOp with identity for the ValLoc case.

---
 include/RAJA/pattern/params/reducer.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 597705c8da..78b6d7714d 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -121,11 +121,11 @@ namespace detail
 
     // ValLoc constructor
     // Note that the target_ variables point to the val and loc within the user defined target ValLoc
-    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VOp(target_in->val, target_in->loc)), target_value(&target_in->val), target_index(&target_in->loc) {}
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VOp{}), target_value(&target_in->val), target_index(&target_in->loc) {}
 
     // Dual input constructor for ReduceLoc<>(data, index) case
     // The target_ variables point to vars defined by the user
-    RAJA_HOST_DEVICE Reducer(target_value_type *data_in, target_index_type *index_in) : m_valop(VOp(*data_in, *index_in)), target_value(data_in), target_index(index_in) {}
+    RAJA_HOST_DEVICE Reducer(target_value_type *data_in, target_index_type *index_in) : m_valop(VOp{}), target_value(data_in), target_index(index_in) {}
 
     Reducer(Reducer const &) = default;
     Reducer(Reducer &&) = default;